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