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
  31 static int cl_ui     = 1,
  32            cl_menu   = 0;
  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    vg_loader_highwater( NULL, highscores_save_at_exit, NULL );
  65
  66    vg_sleep_ms(200);
  67
  68    steam_init();
  69    vg_loader_highwater( NULL, steam_end, NULL );
  70
  71    vg_loader_highwater( network_init, network_end, NULL );
  72 }
  73
  74 void vg_load(void)
  75 {
  76    vg_loader_highwater( render_init, render_free, NULL );
  77    vg_loader_highwater( world_init, world_free, NULL );
  78    vg_loader_highwater( player_init, NULL, NULL );
  79
  80    if( !vg_bake_shaders() )
  81       vg_fatal_exit_loop( "Did not load all shaders" );
  82
  83    vg_loader_highwater( audio_init, audio_free, NULL );
  84
  85    /* FInal step */
  86    world_load();
  87    vg_console_load_autos();
  88 }
  89
  90 static void vg_start(void)
  91 {
  92    player_load_model( "ch_new" );
  93    reset_player( 1, (const char *[]){ "start" } );
  94 }
  95
  96 static void draw_origin_axis(void)
  97 {
  98    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
  99    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 100    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 101 }
 102
 103 void vg_update( int loaded )
 104 {
 105    steam_update();
 106
 107    if( loaded )
 108    {
 109       draw_origin_axis();
 110       network_update();
 111       player_update_pre();
 112       world_update( player.phys.rb.co );
 113    }
 114
 115    if( vg_get_button_down( "menu" ) )
 116    {
 117       cl_menu = !cl_menu;
 118    }
 119 }
 120
 121 static void vg_update_fixed( int loaded )
 122 {
 123    if( loaded )
 124    {
 125       player_update_fixed();
 126    }
 127 }
 128
 129 static void vg_update_post( int loaded )
 130 {
 131    if( loaded )
 132    {
 133       player_update_post();
 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( player.camera_inverse, world_4x4 );
 148
 149    static float fov = 97.0f;
 150    float fov_target = player.phys.on_board? 125.0f: 108.0f;
 151    fov = vg_lerpf( fov, fov_target, vg.time_delta * 2.0f );
 152
 153    gpipeline.fov = freecam? 60.0f: fov; /* 120 */
 154    m4x4_projection( vg.pv, gpipeline.fov,
 155          (float)vg.window_x / (float)vg.window_y,
 156          0.02f, 2100.0f );
 157
 158    m4x4_mul( vg.pv, world_4x4, vg.pv );
 159    glEnable( GL_DEPTH_TEST );
 160
 161    /*
 162     * Draw world
 163     */
 164
 165    int draw_solid = player.is_dead | freecam;
 166
 167    render_world( vg.pv, player.camera );
 168    if( draw_solid )
 169       draw_player();
 170    render_water_texture( player.camera );
 171
 172    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 173    render_water_surface( vg.pv, player.camera );
 174
 175    render_world_gates( vg.pv, player.phys.rb.co, player.camera );
 176
 177    /* Copy the RGB of what we have into the background buffer */
 178    glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 );
 179    glBindFramebuffer( GL_DRAW_FRAMEBUFFER, gpipeline.fb_background );
 180    glBlitFramebuffer( 0,0, vg.window_x, vg.window_y,
 181                       0,0, vg.window_x, vg.window_y,
 182                       GL_COLOR_BUFFER_BIT,
 183                       GL_LINEAR );
 184
 185    /* Clear out the colour buffer, but keep depth */
 186    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 187    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
 188
 189    if( !player.is_dead )
 190       glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 191    else
 192       glClear( GL_COLOR_BUFFER_BIT );
 193
 194    if( !draw_solid )
 195    {
 196       m4x4_projection( vg.pv, gpipeline.fov,
 197             (float)vg.window_x / (float)vg.window_y,
 198             0.01f, 600.0f );
 199       m4x4_mul( vg.pv, world_4x4, vg.pv );
 200       draw_player();
 201    }
 202
 203    /* Draw back in the background
 204     *
 205     * TODO: need to disable alpha write in the terrain shader so this works
 206     *       again.
 207     */
 208    glEnable(GL_BLEND);
 209    glDisable(GL_DEPTH_TEST);
 210    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 211    glBlendEquation(GL_FUNC_ADD);
 212
 213    shader_blit_use();
 214    shader_blit_uTexMain( 0 );
 215    glActiveTexture(GL_TEXTURE0);
 216    glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
 217
 218    render_fsquad();
 219 }
 220
 221 void vg_render(void)
 222 {
 223    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 224    glViewport( 0,0, vg.window_x, vg.window_y );
 225    glDisable( GL_DEPTH_TEST );
 226
 227    glClearColor( 0.11f, 0.35f, 0.37f, 1.0f );
 228    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 229
 230    render_main_game();
 231
 232
 233    /* Other shite */
 234    glDisable(GL_BLEND);
 235    glDisable( GL_DEPTH_TEST );
 236    vg_lines_drawall( (float *)vg.pv );
 237    glViewport( 0,0, vg.window_x, vg.window_y );
 238 }
 239
 240 void vg_ui(void)
 241 {
 242    if( cl_menu )
 243    {
 244       ui_rect menu =
 245       {
 246          vg.window_x / 2 - 150,
 247          vg.window_y / 2 - 50,
 248          300,
 249          130
 250       };
 251
 252       ui_fill_rect( &ui_global_ctx, menu, 0xa0000000 );
 253
 254       ui_text( &ui_global_ctx, (ui_rect){ menu[0]+menu[2]/2,menu[1]+6, 0, 0 },
 255                                steam_username_at_startup,
 256                                1, k_text_align_center );
 257       menu[1] += 24;
 258       menu[3] -= 30;
 259
 260       ui_rect_pad( menu, 8 );
 261       ui_fill_rect( &ui_global_ctx, menu, 0x90ffffff );
 262       ui_rect_pad( menu, 2 );
 263       ui_fill_rect( &ui_global_ctx, menu, 0xa0000000 );
 264
 265       menu[1] += 32;
 266       ui_text( &ui_global_ctx, (ui_rect){ menu[0]+menu[2]/2,menu[1], 0, 0 },
 267                                "Exit", 2, k_text_align_center );
 268
 269       if( vg_get_button_down( "jump" ) )
 270       {
 271          glfwSetWindowShouldClose( vg.window, 1 );
 272       }
 273    }
 274
 275 #if 0
 276    if( lightedit )
 277    {
 278       ui_global_ctx.cursor[0] = 10;
 279       ui_global_ctx.cursor[1] = 10;
 280       ui_global_ctx.cursor[2] = 200;
 281       ui_global_ctx.cursor[3] = 20;
 282
 283       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 284       struct ui_slider_vector
 285          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 286
 287       struct ui_slider
 288          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 289          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 290
 291       for( int i=0; i<3; i++ )
 292          run_light_widget( &gpipeline.widgets[i] );
 293
 294       gui_text( ui_global_ctx.cursor, "Ambient", 1, 0 );
 295       ui_global_ctx.cursor[1] += 16;
 296       ui_slider_vector( &ui_global_ctx, &s5 );
 297
 298       gui_text( ui_global_ctx.cursor, "Shadows", 1, 0 );
 299       ui_global_ctx.cursor[1] += 16;
 300       ui_slider( &ui_global_ctx, &s8 );
 301       ui_slider( &ui_global_ctx, &s9 );
 302
 303       gui_text( ui_global_ctx.cursor, "Misc", 1, 0 );
 304       ui_global_ctx.cursor[1] += 16;
 305       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 306       ui_checkbox( &ui_global_ctx, &c1 );
 307
 308       render_update_lighting_ub();
 309    }
 310 #endif
 311
 312    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 313    if( cl_ui )
 314    {
 315       render_world_routes_ui();
 316    }
 317    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 318
 319    audio_debug_soundscapes();
 320 }
 321
 322 #if 0
 323 static void run_light_widget( struct light_widget *lw )
 324 {
 325    struct ui_checkbox c1 = { .data=&lw->enabled };
 326
 327    ui_checkbox( &ui_global_ctx, &c1 );
 328
 329    if( lw->enabled )
 330    {
 331       struct ui_slider_vector
 332          colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
 333          dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
 334
 335       ui_slider_vector( &ui_global_ctx, &colour );
 336       ui_global_ctx.cursor[1] += 4;
 337       ui_slider_vector( &ui_global_ctx, &dir );
 338    }
 339 }
 340 #endif
 341
 342 static void run_debug_info(void)
 343 {
 344    char buf[40];
 345
 346    snprintf( buf, 40, "%.2fm/s", v3_length( player.phys.rb.v ) );
 347    gui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 348
 349    snprintf( buf, 40, "%.2f %.2f %.2f m/s",
 350          player.phys.a[0], player.phys.a[1], player.phys.a[2] );
 351    gui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 352
 353    snprintf( buf, 40, "pos %.2f %.2f %.2f",
 354          player.phys.rb.co[0], player.phys.rb.co[1], player.phys.rb.co[2] );
 355    gui_text( (ui_px [2]){ 0, 40 }, buf, 1, k_text_align_left );
 356
 357    if( vg.gamepad_ready )
 358    {
 359       for( int i=0; i<6; i++ )
 360       {
 361          snprintf( buf, 40, "%.2f", vg.gamepad.axes[i] );
 362          gui_text( (ui_px [2]){ 0, (i+3)*20 }, buf, 1, k_text_align_left );
 363       }
 364    }
 365    else
 366    {
 367       gui_text( (ui_px [2]){ 0, 60 },
 368             "Gamepad not ready", 1, k_text_align_left );
 369    }
 370 }