skaterift.c

   1 /*
   2  * =============================================================================
   3  *
   4  * Copyright  .        . .       -----, ,----- ,---.   .---.
   5  * 2021-2023  |\      /| |           /  |      |    | |    /|
   6  *            | \    / | +--        /   +----- +---'  |   / |
   7  *            |  \  /  | |         /    |      |   \  |  /  |
   8  *            |   \/   | |        /     |      |    \ | /   |
   9  *            '        ' '--' [] '----- '----- '     ' '---'  SOFTWARE
  10  *
  11  * =============================================================================
  12  */
  13
  14 #define SR_NETWORKED
  15 #include "common.h"
  16 #include "conf.h"
  17 #include "steam.h"
  18 #include "render.h"
  19 #include "audio.h"
  20 #include "world.h"
  21
  22 #if 0
  23 #include "player.h"
  24 #else
  25 #include "player_interface.h"
  26 #include "player_device_walk.h"
  27 #include "player_device_skate.h"
  28 #include "player_device_dead.h"
  29 #include "player_model.h"
  30
  31 /* temp */
  32 VG_STATIC player_interface localplayer;
  33 VG_STATIC struct player_avatar localplayer_avatar;
  34 VG_STATIC glmesh localplayer_meshes[3];
  35
  36 #endif
  37
  38 #include "network.h"
  39
  40 #if 0
  41 #include "menu.h"
  42 #endif
  43 #include "vehicle.h"
  44
  45 static int cl_ui      = 1,
  46            cl_view_id = 0,
  47            cl_light_edit = 0;
  48
  49 int main( int argc, char *argv[] )
  50 {
  51    vg_mem.use_libc_malloc = 0;
  52    vg_set_mem_quota( 128*1024*1024 );
  53    vg_enter( argc, argv, "Voyager Game Engine" );
  54
  55    return 0;
  56 }
  57
  58 VG_STATIC void highscores_save_at_exit(void)
  59 {
  60    highscores_serialize_all();
  61 }
  62
  63 VG_STATIC void vg_launch_opt(void)
  64 {
  65
  66 }
  67
  68 VG_STATIC int __kill( int argc, const char *argv[] )
  69 {
  70 #if 0
  71    player_use_device( &localplayer, &player_device_dead, &localplayer_dead );
  72 #endif
  73    return 0;
  74 }
  75
  76 VG_STATIC int __respawn( int argc, const char *argv[] )
  77 {
  78    struct respawn_point *rp = NULL, *r;
  79
  80    if( argc == 1 )
  81    {
  82       for( int i=0; i<world.spawn_count; i++ )
  83       {
  84          r = &world.spawns[i];
  85          if( !strcmp( r->name, argv[0] ) )
  86          {
  87             rp = r;
  88             break;
  89          }
  90       }
  91
  92       if( !rp )
  93          vg_warn( "No spawn named '%s'\n", argv[0] );
  94    }
  95
  96    if( !rp )
  97    {
  98       float min_dist = INFINITY;
  99
 100       for( int i=0; i<world.spawn_count; i++ )
 101       {
 102          r = &world.spawns[i];
 103          float d = v3_dist2( r->co, localplayer.rb.co );
 104
 105          vg_info( "Dist %s : %f\n", r->name, d );
 106          if( d < min_dist )
 107          {
 108             min_dist = d;
 109             rp = r;
 110          }
 111       }
 112    }
 113
 114    if( !rp )
 115    {
 116       vg_error( "No spawn found\n" );
 117
 118       if( !world.spawn_count )
 119          return 0;
 120
 121       rp = &world.spawns[0];
 122    }
 123
 124    player_spawn( &localplayer, rp );
 125    return 1;
 126 }
 127
 128 VG_STATIC void vg_preload(void)
 129 {
 130    g_conf_init();
 131
 132    common_var_temp();
 133
 134    vg_var_push( (struct vg_var){
 135       .name = "cl_ui",
 136       .data = &cl_ui,
 137       .data_type = k_var_dtype_i32,
 138       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 139       .persistent = 0
 140    });
 141
 142    vg_var_push( (struct vg_var){
 143       .name = "cl_view_id",
 144       .data = &cl_view_id,
 145       .data_type = k_var_dtype_i32,
 146       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 147       .persistent = 0
 148    });
 149
 150    vg_var_push( (struct vg_var){
 151       .name = "ledit",
 152       .data = &cl_light_edit,
 153       .data_type = k_var_dtype_i32,
 154       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 155       .persistent = 0
 156    });
 157
 158    vg_function_push( (struct vg_cmd) {
 159       .name = "respawn",
 160       .function = __respawn,
 161       //.poll_suggest = reset_player_poll
 162    });
 163
 164    vg_function_push( (struct vg_cmd) {
 165       .name = "ded",
 166       .function = __kill,
 167       //.poll_suggest = reset_player_poll
 168    });
 169
 170 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
 171 vg_info(" 2021-2022  |\\      /| |           /  |      |    | |    /| \n" );
 172 vg_info("            | \\    / | +--        /   +----- +---'  |   / | \n" );
 173 vg_info("            |  \\  /  | |         /    |      |   \\  |  /  | \n" );
 174 vg_info("            |   \\/   | |        /     |      |    \\ | /   | \n" );
 175 vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
 176         "SOFTWARE\n" );
 177
 178    highscores_init( 2000, 50 );
 179    if( !highscores_read() )
 180       highscores_create_db();
 181
 182    vg_loader_step( NULL, highscores_save_at_exit );
 183
 184    steam_init();
 185    vg_loader_step( NULL, steam_end );
 186    vg_loader_step( network_init, network_end );
 187 }
 188
 189 VG_STATIC void load_playermodels(void)
 190 {
 191    vg_linear_clear( vg_mem.scratch );
 192
 193    /*
 194     * load in other player models. This may need to be more sophisticated in
 195     * the futre if we have more of these guys
 196     */
 197    mdl_context ctx_default,
 198                ctx_outlaw,
 199                ctx_jordan;
 200
 201    mdl_open( &ctx_default, "models/ch_new.mdl" );
 202    mdl_load_metadata( &ctx_default, vg_mem.scratch );
 203    mdl_load_mesh_data( &ctx_default, vg_mem.scratch );
 204    mdl_close( &ctx_default );
 205
 206    mdl_open( &ctx_outlaw, "models/ch_outlaw.mdl" );
 207    mdl_load_metadata( &ctx_outlaw, vg_mem.scratch );
 208    mdl_load_mesh_data( &ctx_outlaw, vg_mem.scratch );
 209    mdl_close( &ctx_outlaw );
 210
 211    mdl_open( &ctx_jordan, "models/ch_jordan.mdl" );
 212    mdl_load_metadata( &ctx_jordan, vg_mem.scratch );
 213    mdl_load_mesh_data( &ctx_jordan, vg_mem.scratch );
 214    mdl_close( &ctx_jordan );
 215
 216    vg_acquire_thread_sync();
 217    {
 218       mdl_unpack_glmesh( &ctx_default, &localplayer_meshes[0] );
 219       mdl_unpack_glmesh( &ctx_outlaw,  &localplayer_meshes[1] );
 220       mdl_unpack_glmesh( &ctx_jordan,  &localplayer_meshes[2] );
 221    }
 222    vg_release_thread_sync();
 223
 224    /* FIXME: hack */
 225    shader_viewchar_register();
 226    vg_acquire_thread_sync();
 227    {
 228       vg_tex2d_init( (vg_tex2d *[]){ &tex_characters }, 1 );
 229    }
 230    vg_release_thread_sync();
 231 }
 232
 233 VG_STATIC void vg_load(void)
 234 {
 235    vg_loader_step( render_init, NULL );
 236    //vg_loader_step( menu_init, NULL );
 237    vg_loader_step( world_init, NULL );
 238    //vg_loader_step( player_init, NULL );
 239    //vg_loader_step( vehicle_init, NULL );
 240    //
 241    //vg_loader_step( player_model_init, NULL );
 242
 243    /* ----------------- */
 244    vg_loader_step( load_playermodels, NULL );
 245
 246    /* player setup */
 247    player_interface_create_player( &localplayer );
 248
 249    player_avatar_load( &localplayer_avatar, "models/ch_new.mdl" );
 250    player_use_avatar( &localplayer, &localplayer_avatar );
 251    player_use_mesh( &localplayer, &localplayer_meshes[0] );
 252
 253    player_add_device( &localplayer, &player_device_walk );
 254    player_add_device( &localplayer, &player_device_skate );
 255    player_add_device( &localplayer, &player_device_dead );
 256    player_bind( &localplayer );
 257
 258    /* --------------------- */
 259
 260    vg_bake_shaders();
 261    vg_loader_step( audio_init, audio_free );
 262    world_audio_init();
 263
 264    /* 'systems' are completely loaded now */
 265    strcpy( world.world_name, "maps/mp_mtzero.mdl" );
 266    strcpy( world.world_name, "maps/mp_gridmap.mdl" );
 267    world_load();
 268    vg_console_load_autos();
 269 }
 270
 271 VG_STATIC void vg_start(void)
 272 {
 273    __respawn( 1, (const char *[]){ "start" } );
 274 }
 275
 276 VG_STATIC void draw_origin_axis(void)
 277 {
 278    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 279    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 280    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 281 }
 282
 283 VG_STATIC void vg_update(void)
 284 {
 285    steam_update();
 286
 287    if( vg.is_loaded )
 288    {
 289       draw_origin_axis();
 290       network_update();
 291
 292 #if 0
 293       if( !gzoomer.inside )
 294          player_update_pre();
 295 #endif
 296
 297       player_pre_update( &localplayer );
 298       world_update( localplayer.rb.co );
 299    }
 300 }
 301
 302 VG_STATIC void vg_update_fixed(void)
 303 {
 304    if( vg.is_loaded )
 305    {
 306 #if 0
 307       if( !gzoomer.inside )
 308          player_update_fixed();
 309
 310       vehicle_update_fixed();
 311 #endif
 312
 313       player_update( &localplayer );
 314    }
 315 }
 316
 317 VG_STATIC void vg_update_post(void)
 318 {
 319    if( vg.is_loaded )
 320    {
 321 #if 0
 322       if( gzoomer.inside )
 323       {
 324          vehicle_camera();
 325       }
 326       else
 327       {
 328          player_update_post();
 329       }
 330 #endif
 331
 332       player_post_update( &localplayer );
 333
 334 #if 0
 335       menu_update();
 336       vehicle_update_post();
 337 #endif
 338    }
 339 }
 340
 341 VG_STATIC void vg_framebuffer_resize( int w, int h )
 342 {
 343    render_fb_resize();
 344 }
 345
 346 VG_STATIC void present_view_with_post_processing(void)
 347 {
 348    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 349
 350    glEnable(GL_BLEND);
 351    glDisable(GL_DEPTH_TEST);
 352    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 353    glBlendEquation(GL_FUNC_ADD);
 354
 355    if( cl_blur )
 356    {
 357       shader_blitblur_use();
 358       shader_blitblur_uTexMain( 0 );
 359       shader_blitblur_uTexMotion( 1 );
 360       shader_blitblur_uBlurStrength(cl_blur_strength / (vg.frame_delta*60.0f));
 361
 362       v2f menu_blurring;
 363       //v2_muls( (v2f){ 0.04f, 0.001f }, menu_opacity, menu_blurring );
 364       v2_muls( (v2f){ 0.04f, 0.001f }, 0.0f, menu_blurring );
 365       shader_blitblur_uOverrideDir( menu_blurring );
 366
 367       if( cl_view_id == 0 )
 368          render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 369       else if( cl_view_id == 1 )
 370          render_fb_bind_texture( gpipeline.fb_main, 1, 0 );
 371       else
 372          render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 373
 374       render_fb_bind_texture( gpipeline.fb_main, 1, 1 );
 375    }
 376    else
 377    {
 378       shader_blit_use();
 379       shader_blit_uTexMain( 0 );
 380       render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 381    }
 382
 383    render_fsquad();
 384 }
 385
 386 VG_STATIC void render_player_transparent(void)
 387 {
 388    static camera small_cam;      /* DOES NOT NEED TO BE STATIC BUT MINGW
 389                                     SAIS OTHERWISE */
 390
 391    m4x3_copy( main_camera.transform, small_cam.transform );
 392
 393    small_cam.fov = main_camera.fov;
 394    small_cam.nearz = 0.05f;
 395    small_cam.farz  = 60.0f;
 396
 397    camera_update_view( &small_cam );
 398    camera_update_projection( &small_cam );
 399    camera_finalize( &small_cam );
 400
 401    /* Draw player to window buffer and blend background ontop */
 402    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 403    player_render( &small_cam, &localplayer );
 404 }
 405
 406 VG_STATIC void render_scene(void)
 407 {
 408    render_fb_bind( gpipeline.fb_main );
 409    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
 410    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
 411
 412    /* Draw world */
 413    glEnable( GL_DEPTH_TEST );
 414    render_world( &main_camera );
 415
 416
 417
 418    int player_transparent = 1,
 419        player_draw        = 1;
 420
 421    if( !player_transparent && player_draw )
 422       player_render( &main_camera, &localplayer );
 423
 424    render_water_texture( &main_camera );
 425    render_fb_bind( gpipeline.fb_main );
 426    render_water_surface( &main_camera );
 427    render_world_gates( &main_camera );
 428
 429    if( player_transparent && player_draw )
 430       render_player_transparent();
 431 }
 432
 433 VG_STATIC void render_menu(void)
 434 {
 435    glClear( GL_DEPTH_BUFFER_BIT );
 436 #if 0
 437    menu_render( &main_camera );
 438 #endif
 439 }
 440
 441 VG_STATIC void render_main_game(void)
 442 {
 443 #if 0
 444    static float fov = 60.0f;
 445    float fov_target = vg_lerpf( 90.0f, 110.0f, cl_fov );
 446
 447    if( player.controller == k_player_controller_skate )
 448       fov_target = vg_lerpf( 97.0f, 135.0f, cl_fov );
 449
 450    if( cl_menu )
 451       fov_target = menu_fov_target;
 452    fov = vg_lerpf( fov, fov_target, vg.frame_delta * 2.0f );
 453    fov = freecam? 60.0f: fov;
 454
 455    main_camera.fov   = fov;
 456 #endif
 457
 458    /* copy camera from player.
 459     * TODO: blend with camera from menu */
 460
 461    /* FIXME: TEMP!! */
 462    player_pre_render( &localplayer );
 463
 464    v3_copy( localplayer.cam.pos, main_camera.pos );
 465    v3_copy( localplayer.cam.angles, main_camera.angles );
 466    main_camera.fov = localplayer.cam.fov;
 467    main_camera.nearz = 0.1f;
 468    main_camera.farz  = 2100.0f;
 469
 470    camera_update_transform( &main_camera );
 471    camera_update_view( &main_camera );
 472    camera_update_projection( &main_camera );
 473    camera_finalize( &main_camera );
 474
 475    /* ========== Begin Frame ========== */
 476
 477    render_scene();
 478    present_view_with_post_processing();
 479
 480 #if 0
 481    if( cl_menu )
 482    {
 483       render_menu();
 484       render_player_transparent();
 485    }
 486 #endif
 487
 488    /* =========== End Frame =========== */
 489 }
 490
 491 VG_STATIC void vg_render(void)
 492 {
 493    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 494
 495    glViewport( 0,0, vg.window_x, vg.window_y );
 496    glDisable( GL_DEPTH_TEST );
 497
 498    glClearColor( 1.0f, 0.0f, 0.0f, 0.0f );
 499    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 500
 501    render_main_game();
 502
 503    /* Other shite */
 504    glDisable(GL_BLEND);
 505    glDisable( GL_DEPTH_TEST );
 506    vg_lines_drawall( (float *)main_camera.mtx.pv );
 507    glViewport( 0,0, vg.window_x, vg.window_y );
 508 }
 509
 510 VG_STATIC void run_light_widget( struct light_widget *lw );
 511 VG_STATIC void vg_ui(void)
 512 {
 513    player_ui( &localplayer );
 514
 515 #if 0
 516    menu_crap_ui();
 517 #endif
 518
 519    if( cl_light_edit )
 520    {
 521       vg_uictx.cursor[0] = 10;
 522       vg_uictx.cursor[1] = 10;
 523       vg_uictx.cursor[2] = 200;
 524       vg_uictx.cursor[3] = 20;
 525
 526       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 527       struct ui_slider_vector
 528          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 529
 530       struct ui_slider
 531          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 532          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 533
 534       for( int i=0; i<3; i++ )
 535          run_light_widget( &gpipeline.widgets[i] );
 536
 537       ui_text( vg_uictx.cursor, "Ambient", 1, 0 );
 538       vg_uictx.cursor[1] += 16;
 539       ui_slider_vector( &s5 );
 540
 541       ui_text( vg_uictx.cursor, "Shadows", 1, 0 );
 542       vg_uictx.cursor[1] += 16;
 543       ui_slider( &s8 );
 544       ui_slider( &s9 );
 545
 546       ui_text( vg_uictx.cursor, "Misc", 1, 0 );
 547       vg_uictx.cursor[1] += 16;
 548       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 549       ui_checkbox( &c1 );
 550
 551       render_update_lighting_ub();
 552    }
 553
 554    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 555    if( cl_ui )
 556    {
 557       render_world_routes_ui();
 558    }
 559    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 560
 561    audio_debug_soundscapes();
 562    render_view_framebuffer_ui();
 563
 564 #if 0
 565    player_physics_gui();
 566 #endif
 567 }
 568
 569 VG_STATIC void run_light_widget( struct light_widget *lw )
 570 {
 571    struct ui_checkbox c1 = { .data=&lw->enabled };
 572
 573    ui_checkbox( &c1 );
 574
 575    if( lw->enabled )
 576    {
 577       struct ui_slider_vector
 578          colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
 579          dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
 580
 581       ui_slider_vector( &colour );
 582       vg_uictx.cursor[1] += 4;
 583       ui_slider_vector( &dir );
 584    }
 585 }
 586
 587 VG_STATIC void run_debug_info(void)
 588 {
 589 #if 0
 590    char buf[40];
 591
 592    snprintf( buf, 40, "%.2fm/s", v3_length( player.rb.v ) );
 593    ui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 594
 595    snprintf( buf, 40, "%.2f %.2f %.2f m/s",
 596          player.phys.a[0], player.phys.a[1], player.phys.a[2] );
 597    ui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 598
 599    snprintf( buf, 40, "pos %.2f %.2f %.2f",
 600          player.phys.rb.co[0], player.phys.rb.co[1], player.phys.rb.co[2] );
 601    ui_text( (ui_px [2]){ 0, 40 }, buf, 1, k_text_align_left );
 602
 603    if( vg_input.controller_handle )
 604    {
 605       for( int i=0; i<vg_list_size(vg_input.controller_axises); i++ )
 606       {
 607          snprintf( buf, 40, "%.2f", vg_input.controller_axises[i] );
 608          ui_text( (ui_px [2]){ 0, (i+3)*20 }, buf, 1, k_text_align_left );
 609       }
 610    }
 611    else
 612    {
 613       ui_text( (ui_px [2]){ 0, 60 },
 614             "Gamepad not ready", 1, k_text_align_left );
 615    }
 616 #endif
 617 }