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 #include "player.h"
  22 #include "network.h"
  23 #include "menu.h"
  24 #include "vehicle.h"
  25
  26 static int cl_ui      = 1,
  27            cl_view_id = 0,
  28            cl_light_edit = 0;
  29
  30 int main( int argc, char *argv[] )
  31 {
  32    vg_mem.use_libc_malloc = 0;
  33    vg_set_mem_quota( 128*1024*1024 );
  34    vg_enter( argc, argv, "Voyager Game Engine" );
  35
  36    return 0;
  37 }
  38
  39 VG_STATIC void highscores_save_at_exit(void)
  40 {
  41    highscores_serialize_all();
  42 }
  43
  44 VG_STATIC void vg_launch_opt(void)
  45 {
  46
  47 }
  48
  49 VG_STATIC void vg_preload(void)
  50 {
  51    g_conf_init();
  52
  53    vg_var_push( (struct vg_var){
  54       .name = "cl_ui",
  55       .data = &cl_ui,
  56       .data_type = k_var_dtype_i32,
  57       .opt_i32 = { .min=0, .max=1, .clamp=1 },
  58       .persistent = 0
  59    });
  60
  61    vg_var_push( (struct vg_var){
  62       .name = "cl_view_id",
  63       .data = &cl_view_id,
  64       .data_type = k_var_dtype_i32,
  65       .opt_i32 = { .min=0, .max=1, .clamp=1 },
  66       .persistent = 0
  67    });
  68
  69    vg_var_push( (struct vg_var){
  70       .name = "ledit",
  71       .data = &cl_light_edit,
  72       .data_type = k_var_dtype_i32,
  73       .opt_i32 = { .min=0, .max=1, .clamp=1 },
  74       .persistent = 0
  75    });
  76
  77 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
  78 vg_info(" 2021-2022  |\\      /| |           /  |      |    | |    /| \n" );
  79 vg_info("            | \\    / | +--        /   +----- +---'  |   / | \n" );
  80 vg_info("            |  \\  /  | |         /    |      |   \\  |  /  | \n" );
  81 vg_info("            |   \\/   | |        /     |      |    \\ | /   | \n" );
  82 vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
  83         "SOFTWARE\n" );
  84
  85    highscores_init( 2000, 50 );
  86    if( !highscores_read() )
  87       highscores_create_db();
  88
  89    vg_loader_step( NULL, highscores_save_at_exit );
  90
  91    steam_init();
  92    vg_loader_step( NULL, steam_end );
  93    vg_loader_step( network_init, network_end );
  94 }
  95
  96 VG_STATIC void vg_load(void)
  97 {
  98    vg_loader_step( render_init, NULL );
  99    vg_loader_step( menu_init, NULL );
 100    vg_loader_step( world_init, NULL );
 101    vg_loader_step( player_init, NULL );
 102    vg_loader_step( vehicle_init, NULL );
 103
 104    vg_bake_shaders();
 105    vg_loader_step( audio_init, audio_free );
 106    world_audio_init();
 107
 108    /* 'systems' are completely loaded now */
 109    strcpy( world.world_name, "maps/mp_mtzero.mdl" );
 110    strcpy( world.world_name, "maps/mp_gridmap.mdl" );
 111    world_load();
 112    vg_console_load_autos();
 113 }
 114
 115 VG_STATIC void vg_start(void)
 116 {
 117    reset_player( 1, (const char *[]){ "start" } );
 118 }
 119
 120 VG_STATIC void draw_origin_axis(void)
 121 {
 122    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 123    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 124    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 125 }
 126
 127 VG_STATIC void vg_update(void)
 128 {
 129    steam_update();
 130
 131    if( vg.is_loaded )
 132    {
 133       draw_origin_axis();
 134       network_update();
 135
 136       if( !gzoomer.inside )
 137          player_update_pre();
 138
 139       world_update( player.phys.rb.co );
 140    }
 141 }
 142
 143 VG_STATIC void vg_update_fixed(void)
 144 {
 145    if( vg.is_loaded )
 146    {
 147       if( !gzoomer.inside )
 148          player_update_fixed();
 149
 150       vehicle_update_fixed();
 151    }
 152 }
 153
 154 VG_STATIC void vg_update_post(void)
 155 {
 156    if( vg.is_loaded )
 157    {
 158       if( gzoomer.inside )
 159       {
 160          vehicle_camera();
 161       }
 162       else
 163       {
 164          player_update_post();
 165       }
 166       menu_update();
 167       vehicle_update_post();
 168    }
 169 }
 170
 171 VG_STATIC void vg_framebuffer_resize( int w, int h )
 172 {
 173    render_fb_resize();
 174 }
 175
 176 VG_STATIC void present_view_with_post_processing(void)
 177 {
 178    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 179
 180    glEnable(GL_BLEND);
 181    glDisable(GL_DEPTH_TEST);
 182    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 183    glBlendEquation(GL_FUNC_ADD);
 184
 185    if( cl_blur )
 186    {
 187       shader_blitblur_use();
 188       shader_blitblur_uTexMain( 0 );
 189       shader_blitblur_uTexMotion( 1 );
 190       shader_blitblur_uBlurStrength(cl_blur_strength / (vg.frame_delta*60.0f));
 191
 192       v2f menu_blurring;
 193       v2_muls( (v2f){ 0.04f, 0.001f }, menu_opacity, menu_blurring );
 194       shader_blitblur_uOverrideDir( menu_blurring );
 195
 196       if( cl_view_id == 0 )
 197          render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 198       else if( cl_view_id == 1 )
 199          render_fb_bind_texture( gpipeline.fb_main, 1, 0 );
 200       else
 201          render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 202
 203       render_fb_bind_texture( gpipeline.fb_main, 1, 1 );
 204    }
 205    else
 206    {
 207       shader_blit_use();
 208       shader_blit_uTexMain( 0 );
 209       render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 210    }
 211
 212    render_fsquad();
 213 }
 214
 215 VG_STATIC void render_player_transparent(void)
 216 {
 217    static camera small_cam;      /* DOES NOT NEED TO BE STATIC BUT MINGW
 218                                     SAIS OTHERWISE */
 219
 220    m4x3_copy( main_camera.transform, small_cam.transform );
 221
 222    small_cam.fov = main_camera.fov;
 223    small_cam.nearz = 0.05f;
 224    small_cam.farz  = 60.0f;
 225
 226    camera_update_view( &small_cam );
 227    camera_update_projection( &small_cam );
 228    camera_finalize( &small_cam );
 229
 230    /* Draw player to window buffer and blend background ontop */
 231
 232    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 233    draw_player( &small_cam );
 234 }
 235
 236 VG_STATIC void render_scene(void)
 237 {
 238    render_fb_bind( gpipeline.fb_main );
 239    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
 240    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 241
 242    /* Draw world */
 243    glEnable( GL_DEPTH_TEST );
 244
 245    render_world( &main_camera );
 246
 247    int player_transparent = !(player.is_dead || freecam),
 248        player_draw        = !cl_menu;
 249
 250    if( !player_transparent && player_draw )
 251       draw_player( &main_camera );
 252
 253    render_water_texture( &main_camera );
 254    render_fb_bind( gpipeline.fb_main );
 255    render_water_surface( &main_camera );
 256    render_world_gates( &main_camera );
 257
 258    if( player_transparent && player_draw )
 259       render_player_transparent();
 260 }
 261
 262 VG_STATIC void render_menu(void)
 263 {
 264    glClear( GL_DEPTH_BUFFER_BIT );
 265    menu_render( &main_camera );
 266 }
 267
 268 VG_STATIC void render_main_game(void)
 269 {
 270    static float fov = 60.0f;
 271    float fov_target = vg_lerpf( 90.0f, 110.0f, cl_fov );
 272    if( player.phys.on_board )
 273       fov_target = vg_lerpf( 97.0f, 135.0f, cl_fov );
 274    if( cl_menu )
 275       fov_target = menu_fov_target;
 276    fov = vg_lerpf( fov, fov_target, vg.frame_delta * 2.0f );
 277    fov = freecam? 60.0f: fov;
 278
 279    main_camera.fov   = fov;
 280    main_camera.nearz = 0.1f;
 281    main_camera.farz  = 2100.0f;
 282
 283    camera_update_view( &main_camera );
 284    camera_update_projection( &main_camera );
 285    camera_finalize( &main_camera );
 286
 287    /* ========== Begin Frame ========== */
 288
 289    render_scene();
 290    present_view_with_post_processing();
 291
 292    if( cl_menu )
 293    {
 294       render_menu();
 295       render_player_transparent();
 296    }
 297
 298    /* =========== End Frame =========== */
 299 }
 300
 301 VG_STATIC void vg_render(void)
 302 {
 303    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 304
 305    glViewport( 0,0, vg.window_x, vg.window_y );
 306    glDisable( GL_DEPTH_TEST );
 307
 308    glClearColor( 1.0f, 0.0f, 0.0f, 0.0f );
 309    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 310
 311    render_main_game();
 312
 313    /* Other shite */
 314    glDisable(GL_BLEND);
 315    glDisable( GL_DEPTH_TEST );
 316    vg_lines_drawall( (float *)main_camera.mtx.pv );
 317    glViewport( 0,0, vg.window_x, vg.window_y );
 318 }
 319
 320 VG_STATIC void run_light_widget( struct light_widget *lw );
 321 VG_STATIC void vg_ui(void)
 322 {
 323    menu_crap_ui();
 324
 325    if( cl_light_edit )
 326    {
 327       vg_uictx.cursor[0] = 10;
 328       vg_uictx.cursor[1] = 10;
 329       vg_uictx.cursor[2] = 200;
 330       vg_uictx.cursor[3] = 20;
 331
 332       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 333       struct ui_slider_vector
 334          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 335
 336       struct ui_slider
 337          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 338          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 339
 340       for( int i=0; i<3; i++ )
 341          run_light_widget( &gpipeline.widgets[i] );
 342
 343       ui_text( vg_uictx.cursor, "Ambient", 1, 0 );
 344       vg_uictx.cursor[1] += 16;
 345       ui_slider_vector( &s5 );
 346
 347       ui_text( vg_uictx.cursor, "Shadows", 1, 0 );
 348       vg_uictx.cursor[1] += 16;
 349       ui_slider( &s8 );
 350       ui_slider( &s9 );
 351
 352       ui_text( vg_uictx.cursor, "Misc", 1, 0 );
 353       vg_uictx.cursor[1] += 16;
 354       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 355       ui_checkbox( &c1 );
 356
 357       render_update_lighting_ub();
 358    }
 359
 360    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 361    if( cl_ui )
 362    {
 363       render_world_routes_ui();
 364    }
 365    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 366
 367    audio_debug_soundscapes();
 368    render_view_framebuffer_ui();
 369    player_physics_gui();
 370 }
 371
 372 VG_STATIC void run_light_widget( struct light_widget *lw )
 373 {
 374    struct ui_checkbox c1 = { .data=&lw->enabled };
 375
 376    ui_checkbox( &c1 );
 377
 378    if( lw->enabled )
 379    {
 380       struct ui_slider_vector
 381          colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
 382          dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
 383
 384       ui_slider_vector( &colour );
 385       vg_uictx.cursor[1] += 4;
 386       ui_slider_vector( &dir );
 387    }
 388 }
 389
 390 VG_STATIC void run_debug_info(void)
 391 {
 392    char buf[40];
 393
 394    snprintf( buf, 40, "%.2fm/s", v3_length( player.phys.rb.v ) );
 395    ui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 396
 397    snprintf( buf, 40, "%.2f %.2f %.2f m/s",
 398          player.phys.a[0], player.phys.a[1], player.phys.a[2] );
 399    ui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 400
 401    snprintf( buf, 40, "pos %.2f %.2f %.2f",
 402          player.phys.rb.co[0], player.phys.rb.co[1], player.phys.rb.co[2] );
 403    ui_text( (ui_px [2]){ 0, 40 }, buf, 1, k_text_align_left );
 404
 405    if( vg_input.controller_handle )
 406    {
 407       for( int i=0; i<vg_list_size(vg_input.controller_axises); i++ )
 408       {
 409          snprintf( buf, 40, "%.2f", vg_input.controller_axises[i] );
 410          ui_text( (ui_px [2]){ 0, (i+3)*20 }, buf, 1, k_text_align_left );
 411       }
 412    }
 413    else
 414    {
 415       ui_text( (ui_px [2]){ 0, 60 },
 416             "Gamepad not ready", 1, k_text_align_left );
 417    }
 418 }