main.c

   1 /*
   2  * =============================================================================
   3  *
   4  * Copyright  .        . .       -----, ,----- ,---.   .---.
   5  * 2021-2022  |\      /| |           /  |      |    | |    /|
   6  *            | \    / | +--        /   +----- +---'  |   / |
   7  *            |  \  /  | |         /    |      |   \  |  /  |
   8  *            |   \/   | |        /     |      |    \ | /   |
   9  *            '        ' '--' [] '----- '----- '     ' '---'  SOFTWARE
  10  *
  11  * =============================================================================
  12  *
  13  * register: shader register & init scheduling
  14  * init:     initialization
  15  * update:   logic
  16  * render:   graphics
  17  * free:     resource free
  18  *
  19  */
  20
  21 #define VG_3D
  22 #define VG_STATIC static
  23
  24 //#define VG_MINIMAL_TEST
  25 #ifndef VG_MINIMAL_TEST
  26
  27 #define SR_NETWORKED
  28
  29 #include "common.h"
  30 #include "steam.h"
  31 #include "render.h"
  32 #include "audio.h"
  33 #include "world.h"
  34 #include "player.h"
  35 #include "network.h"
  36 #include "menu.h"
  37
  38 static int cl_ui     = 1;
  39
  40 int main( int argc, char *argv[] )
  41 {
  42    vg_prealloc_quota( 128*1024*1024 );
  43    vg_enter( argc, argv, "Voyager Game Engine" );
  44 }
  45
  46 VG_STATIC void highscores_save_at_exit(void*_)
  47 {
  48    highscores_serialize_all();
  49 }
  50
  51 VG_STATIC void vg_preload(void)
  52 {
  53    vg_convar_push( (struct vg_convar){
  54       .name = "cl_ui",
  55       .data = &cl_ui,
  56       .data_type = k_convar_dtype_i32,
  57       .opt_i32 = { .min=0, .max=1, .clamp=1 },
  58       .persistent = 1
  59    });
  60
  61 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
  62 vg_info(" 2021-2022  |\\      /| |           /  |      |    | |    /| \n" );
  63 vg_info("            | \\    / | +--        /   +----- +---'  |   / | \n" );
  64 vg_info("            |  \\  /  | |         /    |      |   \\  |  /  | \n" );
  65 vg_info("            |   \\/   | |        /     |      |    \\ | /   | \n" );
  66 vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
  67         "SOFTWARE\n" );
  68
  69    highscores_init( 2000, 50 );
  70    if( !highscores_read() )
  71       highscores_create_db();
  72
  73    vg_loader_highwater( NULL, highscores_save_at_exit, NULL );
  74
  75    vg_sleep_ms(200);
  76
  77    steam_init();
  78    vg_loader_highwater( NULL, steam_end, NULL );
  79    vg_loader_highwater( network_init, network_end, NULL );
  80 }
  81
  82 VG_STATIC void vg_load(void)
  83 {
  84    vg_loader_highwater( render_init, NULL, NULL );
  85    vg_loader_highwater( menu_init, NULL, NULL );
  86    vg_loader_highwater( world_init, NULL, NULL );
  87    vg_loader_highwater( player_init, NULL, NULL );
  88
  89    vg_bake_shaders();
  90    vg_loader_highwater( audio_init, audio_free, NULL );
  91
  92    /* 'systems' are completely loaded now */
  93    world_load( "models/mp_dev.mdl" );
  94    vg_console_load_autos();
  95 }
  96
  97 VG_STATIC void vg_start(void)
  98 {
  99    reset_player( 1, (const char *[]){ "start" } );
 100 }
 101
 102 VG_STATIC void draw_origin_axis(void)
 103 {
 104    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 105    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 106    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 107 }
 108
 109 VG_STATIC void vg_update( int loaded )
 110 {
 111    steam_update();
 112
 113    if( loaded )
 114    {
 115       draw_origin_axis();
 116       network_update();
 117
 118       player_update_pre();
 119       world_update( player.phys.rb.co );
 120    }
 121 }
 122
 123 VG_STATIC void vg_update_fixed( int loaded )
 124 {
 125    if( loaded )
 126    {
 127       player_update_fixed();
 128    }
 129 }
 130
 131 VG_STATIC void vg_update_post( int loaded )
 132 {
 133    if( loaded )
 134    {
 135       player_update_post();
 136       menu_update();
 137    }
 138 }
 139
 140 VG_STATIC void vg_framebuffer_resize( int w, int h )
 141 {
 142    render_fb_resize();
 143    water_fb_resize();
 144 }
 145
 146 VG_STATIC void render_main_game(void)
 147 {
 148    m4x4f world_4x4;
 149    m4x3_expand( camera_mtx_inverse, world_4x4 );
 150
 151    static float fov = 97.0f;
 152
 153    float fov_target = 108.0f;
 154    if( player.phys.on_board )
 155       fov_target = 125.0f;
 156
 157    if( cl_menu )
 158       fov_target = menu_fov_target;
 159
 160    fov = vg_lerpf( fov, fov_target, vg.frame_delta * 2.0f );
 161
 162    gpipeline.fov = freecam? 60.0f: fov; /* 120 */
 163    m4x4_projection( vg.pv, gpipeline.fov,
 164          (float)vg.window_x / (float)vg.window_y,
 165          0.1f, 2100.0f );
 166
 167    m4x4_mul( vg.pv, world_4x4, vg.pv );
 168    glEnable( GL_DEPTH_TEST );
 169
 170    /*
 171     * Draw world
 172     */
 173
 174    int draw_solid = player.is_dead | freecam;
 175
 176    render_world( vg.pv, camera_mtx );
 177    if( draw_solid )
 178       draw_player( camera_mtx );
 179
 180    render_water_texture( camera_mtx );
 181
 182    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 183    render_water_surface( vg.pv, camera_mtx );
 184    render_world_gates( vg.pv, player.phys.rb.co, camera_mtx );
 185
 186    if( cl_menu )
 187    {
 188       glClear( GL_DEPTH_BUFFER_BIT );
 189       menu_render( vg.pv );
 190    }
 191
 192    /* Copy the RGB of what we have into the background buffer */
 193    glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 );
 194    glBindFramebuffer( GL_DRAW_FRAMEBUFFER, gpipeline.fb_background );
 195    glBlitFramebuffer( 0,0, vg.window_x, vg.window_y,
 196                       0,0, vg.window_x, vg.window_y,
 197                       GL_COLOR_BUFFER_BIT,
 198                       GL_LINEAR );
 199
 200    /* Clear out the colour buffer, but keep depth */
 201    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 202    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
 203
 204    if( !player.is_dead )
 205       glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 206    else
 207       glClear( GL_COLOR_BUFFER_BIT );
 208
 209    if( !draw_solid )
 210    {
 211       m4x4_projection( vg.pv, gpipeline.fov,
 212             (float)vg.window_x / (float)vg.window_y,
 213             0.05f, 60.0f );
 214       m4x4_mul( vg.pv, world_4x4, vg.pv );
 215       draw_player( camera_mtx );
 216    }
 217
 218    /* Draw back in the background
 219     *
 220     * TODO: need to disable alpha write in the terrain shader so this works
 221     *       again.
 222     */
 223    glEnable(GL_BLEND);
 224    glDisable(GL_DEPTH_TEST);
 225    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 226    glBlendEquation(GL_FUNC_ADD);
 227
 228    shader_blit_use();
 229    shader_blit_uTexMain( 0 );
 230    glActiveTexture(GL_TEXTURE0);
 231    glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
 232
 233    render_fsquad();
 234 }
 235
 236 VG_STATIC void vg_render(void)
 237 {
 238    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 239    glViewport( 0,0, vg.window_x, vg.window_y );
 240    glDisable( GL_DEPTH_TEST );
 241
 242    glClearColor( 0.11f, 0.35f, 0.37f, 1.0f );
 243    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 244
 245    render_main_game();
 246
 247
 248    /* Other shite */
 249    glDisable(GL_BLEND);
 250    glDisable( GL_DEPTH_TEST );
 251    vg_lines_drawall( (float *)vg.pv );
 252    glViewport( 0,0, vg.window_x, vg.window_y );
 253 }
 254
 255 VG_STATIC void vg_ui(void)
 256 {
 257 #if 0
 258    if( cl_menu )
 259    {
 260       ui_rect menu =
 261       {
 262          vg.window_x / 2 - 150,
 263          vg.window_y / 2 - 50,
 264          300,
 265          130
 266       };
 267
 268       ui_fill_rect( &ui_global_ctx, menu, 0xa0000000 );
 269
 270       ui_text( &ui_global_ctx, (ui_rect){ menu[0]+menu[2]/2,menu[1]+6, 0, 0 },
 271                                steam_username_at_startup,
 272                                1, k_text_align_center );
 273       menu[1] += 24;
 274       menu[3] -= 30;
 275
 276       ui_rect_pad( menu, 8 );
 277       ui_fill_rect( &ui_global_ctx, menu, 0x90ffffff );
 278       ui_rect_pad( menu, 2 );
 279       ui_fill_rect( &ui_global_ctx, menu, 0xa0000000 );
 280
 281       menu[1] += 32;
 282       ui_text( &ui_global_ctx, (ui_rect){ menu[0]+menu[2]/2,menu[1], 0, 0 },
 283                                "Exit", 2, k_text_align_center );
 284
 285       if( vg_get_button_down( "jump" ) )
 286       {
 287          glfwSetWindowShouldClose( vg.window, 1 );
 288       }
 289    }
 290
 291    if( lightedit )
 292    {
 293       ui_global_ctx.cursor[0] = 10;
 294       ui_global_ctx.cursor[1] = 10;
 295       ui_global_ctx.cursor[2] = 200;
 296       ui_global_ctx.cursor[3] = 20;
 297
 298       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 299       struct ui_slider_vector
 300          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 301
 302       struct ui_slider
 303          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 304          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 305
 306       for( int i=0; i<3; i++ )
 307          run_light_widget( &gpipeline.widgets[i] );
 308
 309       gui_text( ui_global_ctx.cursor, "Ambient", 1, 0 );
 310       ui_global_ctx.cursor[1] += 16;
 311       ui_slider_vector( &ui_global_ctx, &s5 );
 312
 313       gui_text( ui_global_ctx.cursor, "Shadows", 1, 0 );
 314       ui_global_ctx.cursor[1] += 16;
 315       ui_slider( &ui_global_ctx, &s8 );
 316       ui_slider( &ui_global_ctx, &s9 );
 317
 318       gui_text( ui_global_ctx.cursor, "Misc", 1, 0 );
 319       ui_global_ctx.cursor[1] += 16;
 320       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 321       ui_checkbox( &ui_global_ctx, &c1 );
 322
 323       render_update_lighting_ub();
 324    }
 325 #endif
 326
 327    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 328    if( cl_ui )
 329    {
 330       render_world_routes_ui();
 331    }
 332    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 333
 334    audio_debug_soundscapes();
 335 }
 336
 337 #if 0
 338 VG_STATIC void run_light_widget( struct light_widget *lw )
 339 {
 340    struct ui_checkbox c1 = { .data=&lw->enabled };
 341
 342    ui_checkbox( &ui_global_ctx, &c1 );
 343
 344    if( lw->enabled )
 345    {
 346       struct ui_slider_vector
 347          colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
 348          dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
 349
 350       ui_slider_vector( &ui_global_ctx, &colour );
 351       ui_global_ctx.cursor[1] += 4;
 352       ui_slider_vector( &ui_global_ctx, &dir );
 353    }
 354 }
 355 #endif
 356
 357 VG_STATIC void run_debug_info(void)
 358 {
 359    char buf[40];
 360
 361    snprintf( buf, 40, "%.2fm/s", v3_length( player.phys.rb.v ) );
 362    ui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 363
 364    snprintf( buf, 40, "%.2f %.2f %.2f m/s",
 365          player.phys.a[0], player.phys.a[1], player.phys.a[2] );
 366    ui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 367
 368    snprintf( buf, 40, "pos %.2f %.2f %.2f",
 369          player.phys.rb.co[0], player.phys.rb.co[1], player.phys.rb.co[2] );
 370    ui_text( (ui_px [2]){ 0, 40 }, buf, 1, k_text_align_left );
 371
 372    if( vg.gamepad_ready )
 373    {
 374       for( int i=0; i<6; i++ )
 375       {
 376          snprintf( buf, 40, "%.2f", vg.gamepad.axes[i] );
 377          ui_text( (ui_px [2]){ 0, (i+3)*20 }, buf, 1, k_text_align_left );
 378       }
 379    }
 380    else
 381    {
 382       ui_text( (ui_px [2]){ 0, 60 },
 383             "Gamepad not ready", 1, k_text_align_left );
 384    }
 385 }
 386
 387 #else
 388
 389 #define VG_TIMESTEP_FIXED (1.0/60.0)
 390 #define VG_3D
 391 #define VG_FRAMEBUFFER_RESIZE 1
 392 #include "vg/vg.h"
 393
 394 int main( int argc, char *argv[] )
 395 {
 396    vg_prealloc_quota( 512*1024*1024 );
 397    vg_enter( argc, argv, "Voyager Game Engine" );
 398 }
 399
 400 VG_STATIC void vg_preload(void)
 401 {
 402 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
 403 vg_info(" 2021-2022  |\\      /| |           /  |      |    | |    /| \n" );
 404 vg_info("            | \\    / | +--        /   +----- +---'  |   / | \n" );
 405 vg_info("            |  \\  /  | |         /    |      |   \\  |  /  | \n" );
 406 vg_info("            |   \\/   | |        /     |      |    \\ | /   | \n" );
 407 vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
 408         "SOFTWARE\n" );
 409 }
 410
 411 VG_STATIC void vg_load(void)
 412 {
 413    vg_bake_shaders();
 414    vg_console_load_autos();
 415 }
 416
 417 VG_STATIC void vg_start(void)
 418 {
 419 }
 420
 421 VG_STATIC void vg_update( int loaded )
 422 {
 423 }
 424
 425 VG_STATIC void vg_update_fixed( int loaded )
 426 {
 427 }
 428
 429 VG_STATIC void vg_update_post( int loaded )
 430 {
 431 }
 432
 433 VG_STATIC void vg_framebuffer_resize( int w, int h )
 434 {
 435 }
 436
 437 VG_STATIC void vg_render(void)
 438 {
 439    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 440    glViewport( 0,0, vg.window_x, vg.window_y );
 441    glDisable( GL_DEPTH_TEST );
 442
 443    glClearColor( 0.11f, 0.35f, 0.37f, 1.0f );
 444    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 445
 446    /* Other shite */
 447    glDisable(GL_BLEND);
 448    glDisable( GL_DEPTH_TEST );
 449    vg_lines_drawall( (float *)vg.pv );
 450    glViewport( 0,0, vg.window_x, vg.window_y );
 451 }
 452
 453 VG_STATIC void vg_ui(void)
 454 {
 455 }
 456
 457 #endif