main.c

   1 /*
   2  * =============================================================================
   3  *
   4  * Copyright  .        . .       -----, ,----- ,---.   .---.
   5  * 2021-2022  |\      /| |           /  |      |    | |    /|
   6  *            | \    / | +--        /   +----- +---'  |   / |
   7  *            |  \  /  | |         /    |      |   \  |  /  |
   8  *            |   \/   | |        /     |      |    \ | /   |
   9  *            '        ' '--' [] '----- '----- '     ' '---'  SOFTWARE
  10  *
  11  * =============================================================================
  12  *
  13  * register: shader register & init scheduling
  14  * init:     initialization
  15  * update:   logic
  16  * render:   graphics
  17  * free:     resource free
  18  *
  19  */
  20
  21 #define SR_NETWORKED
  22 #define VG_3D
  23 #include "common.h"
  24 #include "steam.h"
  25 #include "render.h"
  26 #include "audio.h"
  27 #include "world.h"
  28 #include "player.h"
  29 #include "network.h"
  30 #include "menu.h"
  31
  32 static int cl_ui     = 1;
  33
  34 int main( int argc, char *argv[] )
  35 {
  36    vg_enter( argc, argv, "Voyager Game Engine" );
  37 }
  38
  39 static void highscores_save_at_exit(void*_)
  40 {
  41    highscores_serialize_all();
  42    highscores_free();
  43 }
  44
  45 void vg_preload(void)
  46 {
  47    vg_convar_push( (struct vg_convar){
  48       .name = "cl_ui",
  49       .data = &cl_ui,
  50       .data_type = k_convar_dtype_i32,
  51       .opt_i32 = { .min=0, .max=1, .clamp=1 },
  52       .persistent = 1
  53    });
  54
  55 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
  56 vg_info(" 2021-2022  |\\      /| |           /  |      |    | |    /| \n" );
  57 vg_info("            | \\    / | +--        /   +----- +---'  |   / | \n" );
  58 vg_info("            |  \\  /  | |         /    |      |   \\  |  /  | \n" );
  59 vg_info("            |   \\/   | |        /     |      |    \\ | /   | \n" );
  60 vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
  61         "SOFTWARE\n" );
  62
  63    highscores_init( 2000, 50 );
  64    if( !highscores_read() )
  65       highscores_create_db();
  66
  67    vg_loader_highwater( NULL, highscores_save_at_exit, NULL );
  68
  69    vg_sleep_ms(200);
  70
  71    steam_init();
  72    vg_loader_highwater( NULL, steam_end, NULL );
  73    vg_loader_highwater( network_init, network_end, NULL );
  74 }
  75
  76 void vg_load(void)
  77 {
  78    vg_loader_highwater( render_init, render_free, NULL );
  79    vg_loader_highwater( menu_init, menu_free, NULL );
  80    vg_loader_highwater( world_init, world_free, NULL );
  81    vg_loader_highwater( player_init, NULL, NULL );
  82
  83    if( !vg_bake_shaders() )
  84       vg_fatal_exit_loop( "Did not load all shaders" );
  85
  86    vg_loader_highwater( audio_init, audio_free, NULL );
  87
  88    /* FInal step */
  89    world_load();
  90    vg_console_load_autos();
  91 }
  92
  93 static void vg_start(void)
  94 {
  95    player_load_model( "ch_jordan", 0 );
  96    reset_player( 1, (const char *[]){ "start" } );
  97 }
  98
  99 static void draw_origin_axis(void)
 100 {
 101    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 102    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 103    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 104 }
 105
 106 void vg_update( int loaded )
 107 {
 108    steam_update();
 109
 110    if( loaded )
 111    {
 112       draw_origin_axis();
 113       network_update();
 114
 115       player_update_pre();
 116       world_update( player.phys.rb.co );
 117    }
 118 }
 119
 120 static void vg_update_fixed( int loaded )
 121 {
 122    if( loaded )
 123    {
 124       player_update_fixed();
 125    }
 126 }
 127
 128 static void vg_update_post( int loaded )
 129 {
 130    if( loaded )
 131    {
 132       player_update_post();
 133       menu_update();
 134    }
 135 }
 136
 137 static void vg_framebuffer_resize( int w, int h )
 138 {
 139    render_fb_resize();
 140    gate_fb_resize();
 141    water_fb_resize();
 142 }
 143
 144 static void render_main_game(void)
 145 {
 146    m4x4f world_4x4;
 147    m4x3_expand( camera_mtx_inverse, world_4x4 );
 148
 149    static float fov = 97.0f;
 150
 151    float fov_target = 108.0f;
 152    if( player.phys.on_board )
 153       fov_target = 125.0f;
 154
 155    if( cl_menu )
 156       fov_target = menu_fov_target;
 157
 158    fov = vg_lerpf( fov, fov_target, vg.frame_delta * 2.0f );
 159
 160    gpipeline.fov = freecam? 60.0f: fov; /* 120 */
 161    m4x4_projection( vg.pv, gpipeline.fov,
 162          (float)vg.window_x / (float)vg.window_y,
 163          0.1f, 2100.0f );
 164
 165    m4x4_mul( vg.pv, world_4x4, vg.pv );
 166    glEnable( GL_DEPTH_TEST );
 167
 168    /*
 169     * Draw world
 170     */
 171
 172    int draw_solid = player.is_dead | freecam;
 173
 174    render_world( vg.pv, camera_mtx );
 175    if( draw_solid )
 176       draw_player( camera_mtx );
 177
 178    render_water_texture( camera_mtx );
 179
 180    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 181    render_water_surface( vg.pv, camera_mtx );
 182    render_world_gates( vg.pv, player.phys.rb.co, camera_mtx );
 183
 184    if( cl_menu )
 185    {
 186       glClear( GL_DEPTH_BUFFER_BIT );
 187       menu_render( vg.pv );
 188    }
 189
 190    /* Copy the RGB of what we have into the background buffer */
 191    glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 );
 192    glBindFramebuffer( GL_DRAW_FRAMEBUFFER, gpipeline.fb_background );
 193    glBlitFramebuffer( 0,0, vg.window_x, vg.window_y,
 194                       0,0, vg.window_x, vg.window_y,
 195                       GL_COLOR_BUFFER_BIT,
 196                       GL_LINEAR );
 197
 198    /* Clear out the colour buffer, but keep depth */
 199    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 200    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
 201
 202    if( !player.is_dead )
 203       glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 204    else
 205       glClear( GL_COLOR_BUFFER_BIT );
 206
 207    if( !draw_solid )
 208    {
 209       m4x4_projection( vg.pv, gpipeline.fov,
 210             (float)vg.window_x / (float)vg.window_y,
 211             0.05f, 60.0f );
 212       m4x4_mul( vg.pv, world_4x4, vg.pv );
 213       draw_player( camera_mtx );
 214    }
 215
 216    /* Draw back in the background
 217     *
 218     * TODO: need to disable alpha write in the terrain shader so this works
 219     *       again.
 220     */
 221    glEnable(GL_BLEND);
 222    glDisable(GL_DEPTH_TEST);
 223    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 224    glBlendEquation(GL_FUNC_ADD);
 225
 226    shader_blit_use();
 227    shader_blit_uTexMain( 0 );
 228    glActiveTexture(GL_TEXTURE0);
 229    glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
 230
 231    render_fsquad();
 232 }
 233
 234 void vg_render(void)
 235 {
 236    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 237    glViewport( 0,0, vg.window_x, vg.window_y );
 238    glDisable( GL_DEPTH_TEST );
 239
 240    glClearColor( 0.11f, 0.35f, 0.37f, 1.0f );
 241    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 242
 243    render_main_game();
 244
 245
 246    /* Other shite */
 247    glDisable(GL_BLEND);
 248    glDisable( GL_DEPTH_TEST );
 249    vg_lines_drawall( (float *)vg.pv );
 250    glViewport( 0,0, vg.window_x, vg.window_y );
 251 }
 252
 253 void vg_ui(void)
 254 {
 255 #if 0
 256    if( cl_menu )
 257    {
 258       ui_rect menu =
 259       {
 260          vg.window_x / 2 - 150,
 261          vg.window_y / 2 - 50,
 262          300,
 263          130
 264       };
 265
 266       ui_fill_rect( &ui_global_ctx, menu, 0xa0000000 );
 267
 268       ui_text( &ui_global_ctx, (ui_rect){ menu[0]+menu[2]/2,menu[1]+6, 0, 0 },
 269                                steam_username_at_startup,
 270                                1, k_text_align_center );
 271       menu[1] += 24;
 272       menu[3] -= 30;
 273
 274       ui_rect_pad( menu, 8 );
 275       ui_fill_rect( &ui_global_ctx, menu, 0x90ffffff );
 276       ui_rect_pad( menu, 2 );
 277       ui_fill_rect( &ui_global_ctx, menu, 0xa0000000 );
 278
 279       menu[1] += 32;
 280       ui_text( &ui_global_ctx, (ui_rect){ menu[0]+menu[2]/2,menu[1], 0, 0 },
 281                                "Exit", 2, k_text_align_center );
 282
 283       if( vg_get_button_down( "jump" ) )
 284       {
 285          glfwSetWindowShouldClose( vg.window, 1 );
 286       }
 287    }
 288
 289    if( lightedit )
 290    {
 291       ui_global_ctx.cursor[0] = 10;
 292       ui_global_ctx.cursor[1] = 10;
 293       ui_global_ctx.cursor[2] = 200;
 294       ui_global_ctx.cursor[3] = 20;
 295
 296       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 297       struct ui_slider_vector
 298          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 299
 300       struct ui_slider
 301          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 302          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 303
 304       for( int i=0; i<3; i++ )
 305          run_light_widget( &gpipeline.widgets[i] );
 306
 307       gui_text( ui_global_ctx.cursor, "Ambient", 1, 0 );
 308       ui_global_ctx.cursor[1] += 16;
 309       ui_slider_vector( &ui_global_ctx, &s5 );
 310
 311       gui_text( ui_global_ctx.cursor, "Shadows", 1, 0 );
 312       ui_global_ctx.cursor[1] += 16;
 313       ui_slider( &ui_global_ctx, &s8 );
 314       ui_slider( &ui_global_ctx, &s9 );
 315
 316       gui_text( ui_global_ctx.cursor, "Misc", 1, 0 );
 317       ui_global_ctx.cursor[1] += 16;
 318       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 319       ui_checkbox( &ui_global_ctx, &c1 );
 320
 321       render_update_lighting_ub();
 322    }
 323 #endif
 324
 325    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 326    if( cl_ui )
 327    {
 328       render_world_routes_ui();
 329    }
 330    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 331
 332    audio_debug_soundscapes();
 333 }
 334
 335 #if 0
 336 static void run_light_widget( struct light_widget *lw )
 337 {
 338    struct ui_checkbox c1 = { .data=&lw->enabled };
 339
 340    ui_checkbox( &ui_global_ctx, &c1 );
 341
 342    if( lw->enabled )
 343    {
 344       struct ui_slider_vector
 345          colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
 346          dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
 347
 348       ui_slider_vector( &ui_global_ctx, &colour );
 349       ui_global_ctx.cursor[1] += 4;
 350       ui_slider_vector( &ui_global_ctx, &dir );
 351    }
 352 }
 353 #endif
 354
 355 static void run_debug_info(void)
 356 {
 357    char buf[40];
 358
 359    snprintf( buf, 40, "%.2fm/s", v3_length( player.phys.rb.v ) );
 360    gui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 361
 362    snprintf( buf, 40, "%.2f %.2f %.2f m/s",
 363          player.phys.a[0], player.phys.a[1], player.phys.a[2] );
 364    gui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 365
 366    snprintf( buf, 40, "pos %.2f %.2f %.2f",
 367          player.phys.rb.co[0], player.phys.rb.co[1], player.phys.rb.co[2] );
 368    gui_text( (ui_px [2]){ 0, 40 }, buf, 1, k_text_align_left );
 369
 370    if( vg.gamepad_ready )
 371    {
 372       for( int i=0; i<6; i++ )
 373       {
 374          snprintf( buf, 40, "%.2f", vg.gamepad.axes[i] );
 375          gui_text( (ui_px [2]){ 0, (i+3)*20 }, buf, 1, k_text_align_left );
 376       }
 377    }
 378    else
 379    {
 380       gui_text( (ui_px [2]){ 0, 60 },
 381             "Gamepad not ready", 1, k_text_align_left );
 382    }
 383 }