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