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