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