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