main.c

   1 /*
   2  * Copyright (C) Mount0 Software, Harry Godden - All Rights Reserved
   3  */
   4
   5 #include "common.h"
   6
   7 /* Resources */
   8 vg_tex2d tex_norwey = { .path = "textures/norway_foliage.qoi" };
   9 vg_tex2d tex_grid = { .path = "textures/grid.qoi" };
  10 vg_tex2d tex_sky = { .path = "textures/sky.qoi" };
  11 vg_tex2d tex_gradients = { .path = "textures/gradients.qoi",
  12                            .flags = VG_TEXTURE_CLAMP };
  13 vg_tex2d tex_cement = { .path = "textures/cement512.qoi" };
  14 vg_tex2d tex_water = { .path = "textures/water.qoi" };
  15
  16 /* Convars */
  17 static int debugview = 0;
  18 static int sv_debugcam = 0;
  19 static int lightedit = 0;
  20 static int sv_scene = 1;
  21
  22 /* Components */
  23 #include "road.h"
  24 #include "scene.h"
  25 #include "ik.h"
  26 #include "audio.h"
  27 #include "terrain.h"
  28 #include "character.h"
  29 #include "ragdoll.h"
  30 #include "rigidbody.h"
  31 #include "render.h"
  32 #include "gate.h"
  33 #include "water.h"
  34 #include "world.h"
  35 #include "player.h"
  36
  37 #include "shaders/blit.h"
  38 #include "shaders/standard.h"
  39 #include "shaders/unlit.h"
  40
  41 #include "physics_test.h"
  42
  43 void vg_register(void)
  44 {
  45    shader_blit_register();
  46    shader_standard_register();
  47    shader_vblend_register();
  48    shader_unlit_register();
  49
  50    world_register();
  51    character_register();
  52    water_register();
  53    gate_register();
  54 }
  55
  56 static void init_other(void)
  57 {
  58    render_init();
  59    gate_init();
  60    world_init();
  61    character_init();
  62    audio_init();
  63 }
  64
  65 vg_tex2d *texture_list[] =
  66 {
  67    &tex_norwey,
  68    &tex_gradients,
  69    &tex_grid,
  70    &tex_sky,
  71    &tex_cement,
  72    &tex_water,
  73    &tex_water_surf
  74 };
  75
  76 int main( int argc, char *argv[] )
  77 {
  78    vg_init( argc, argv, "Voyager Game Engine" );
  79 }
  80
  81 static int playermodel( int argc, char const *argv[] )
  82 {
  83    if( argc < 1 ) return 0;
  84
  85    glmesh old_mesh = player.mdl.mesh;
  86
  87    if( character_load( &player.mdl, argv[0] ) )
  88       mesh_free( &old_mesh );
  89
  90    return 1;
  91 }
  92
  93 void vg_start(void)
  94 {
  95    vg_convar_push( (struct vg_convar){
  96       .name = "scene",
  97       .data = &sv_scene,
  98       .data_type = k_convar_dtype_i32,
  99       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 100       .persistent = 1
 101    });
 102
 103    vg_convar_push( (struct vg_convar){
 104       .name = "fc",
 105       .data = &freecam,
 106       .data_type = k_convar_dtype_i32,
 107       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 108       .persistent = 1
 109    });
 110
 111    vg_convar_push( (struct vg_convar){
 112       .name = "grid",
 113       .data = &walk_grid_iterations,
 114       .data_type = k_convar_dtype_i32,
 115       .opt_i32 = { .min=0, .max=1, .clamp=0 },
 116       .persistent = 1
 117    });
 118
 119    vg_convar_push( (struct vg_convar){
 120       .name = "ledit",
 121       .data = &lightedit,
 122       .data_type = k_convar_dtype_i32,
 123       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 124       .persistent = 1
 125    });
 126
 127    vg_convar_push( (struct vg_convar){
 128       .name = "walk_speed",
 129       .data = &k_walkspeed,
 130       .data_type = k_convar_dtype_f32,
 131       .opt_f32 = { .clamp = 0 },
 132       .persistent = 1
 133    });
 134
 135    vg_convar_push( (struct vg_convar){
 136       .name = "dt",
 137       .data = &ktimestep,
 138       .data_type = k_convar_dtype_f32,
 139       .opt_f32 = { .clamp = 0 },
 140       .persistent = 0
 141    });
 142
 143    vg_convar_push( (struct vg_convar){
 144       .name = "debugcam",
 145       .data = &sv_debugcam,
 146       .data_type = k_convar_dtype_i32,
 147       .opt_i32 = { .min=0, .max=1, .clamp=0 },
 148       .persistent = 1
 149    });
 150
 151    vg_convar_push( (struct vg_convar){
 152       .name = "debugview",
 153       .data = &debugview,
 154       .data_type = k_convar_dtype_i32,
 155       .opt_i32 = { .min=0, .max=1, .clamp=0 },
 156       .persistent = 1
 157    });
 158
 159         vg_function_push( (struct vg_cmd){
 160                 .name = "reset",
 161                 .function = reset_player
 162         });
 163
 164    vg_tex2d_init( texture_list, vg_list_size( texture_list ) );
 165
 166    init_other();
 167
 168    /*
 169     * If we're in physics test mode we dont need to load anything else, this
 170     * parameter is dev only. TODO: dev only cvars that don't ship with the game
 171     * when building in release mode.
 172     */
 173
 174    if( sv_scene == 0 )
 175    {
 176       character_load( &player.mdl, "ch_default" );
 177       character_init_ragdoll( &player.mdl );
 178
 179       world_load();
 180
 181       reset_player( 1, (const char *[]){ "start" } );
 182       rb_init( &player.rb );
 183    }
 184    else
 185    {
 186       physics_test_start();
 187    }
 188 }
 189
 190 void vg_free(void)
 191 {
 192    vg_tex2d_free( texture_list, vg_list_size(texture_list) );
 193 }
 194
 195 void vg_update(void)
 196 {
 197    if( sv_scene == 0 )
 198    {
 199       player_update();
 200       world_update();
 201       //traffic_visualize( world.traffic, world.traffic_count );
 202       //
 203       /* TEMP */
 204       if( glfwGetKey( vg_window, GLFW_KEY_J ))
 205       {
 206          v3_copy( player.camera_pos, world.mr_ball.co );
 207       }
 208    }
 209    else if( sv_scene == 1 )
 210    {
 211       physics_test_update();
 212    }
 213 }
 214
 215 static void vg_framebuffer_resize( int w, int h )
 216 {
 217    render_fb_resize();
 218    gate_fb_resize();
 219    water_fb_resize();
 220 }
 221
 222 static void draw_origin_axis(void)
 223 {
 224    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 225    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 226    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 227 }
 228
 229 static void render_main_game(void)
 230 {
 231    float speed = freecam? 0.0f: v3_length( player.rb.v );
 232    v3f shake = { vg_randf()-0.5f, vg_randf()-0.5f, vg_randf()-0.5f };
 233    v3_muls( shake, speed*0.01f, shake );
 234
 235    m4x4f world_4x4;
 236    m4x3_expand( player.camera_inverse, world_4x4 );
 237
 238    gpipeline.fov = freecam? 60.0f: 135.0f; /* 120 */
 239    m4x4_projection( vg_pv, gpipeline.fov,
 240          (float)vg_window_x / (float)vg_window_y,
 241          0.1f, 2100.0f );
 242
 243    m4x4_mul( vg_pv, world_4x4, vg_pv );
 244
 245    glEnable( GL_DEPTH_TEST );
 246
 247    /*
 248     * Draw world
 249     */
 250
 251    render_world( vg_pv, player.camera );
 252    render_water_texture( player.camera );
 253
 254    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 255    render_water_surface( vg_pv, player.camera );
 256
 257    vg_tex2d_bind( &tex_water, 1 );
 258
 259    for( int i=0; i<world.gate_count; i++ )
 260    {
 261       render_gate( &world.gates[i], player.camera );
 262    }
 263
 264
 265    /* Copy the RGB of what we have into the background buffer */
 266    glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 );
 267    glBindFramebuffer( GL_DRAW_FRAMEBUFFER, gpipeline.fb_background );
 268    glBlitFramebuffer( 0,0, vg_window_x, vg_window_y,
 269                       0,0, vg_window_x, vg_window_y,
 270                       GL_COLOR_BUFFER_BIT,
 271                       GL_LINEAR );
 272
 273    /* Clear out the colour buffer, but keep depth */
 274    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 275    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
 276
 277    if( !player.is_dead )
 278       glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 279    else
 280       glClear( GL_COLOR_BUFFER_BIT );
 281
 282    if( !player.is_dead )
 283    {
 284       m4x4_projection( vg_pv, gpipeline.fov,
 285             (float)vg_window_x / (float)vg_window_y,
 286             0.01f, 100.0f );
 287       m4x4_mul( vg_pv, world_4x4, vg_pv );
 288    }
 289    draw_player();
 290
 291    /* Draw back in the background
 292     *
 293     * TODO: need to disable alpha write in the terrain shader so this works
 294     *       again.
 295     */
 296    glEnable(GL_BLEND);
 297    glDisable(GL_DEPTH_TEST);
 298    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 299    glBlendEquation(GL_FUNC_ADD);
 300
 301    shader_blit_use();
 302    shader_blit_uTexMain( 0 );
 303    glActiveTexture(GL_TEXTURE0);
 304    glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
 305
 306    render_fsquad();
 307    glDisable(GL_BLEND);
 308
 309    /* Other shite */
 310    glDisable( GL_DEPTH_TEST );
 311    vg_lines_drawall( (float *)vg_pv );
 312    glViewport( 0,0, vg_window_x, vg_window_y );
 313 }
 314
 315 void vg_render(void)
 316 {
 317    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 318    glViewport( 0,0, vg_window_x, vg_window_y );
 319
 320    glDisable( GL_DEPTH_TEST );
 321    glClearColor( 0.11f, 0.35f, 0.37f, 1.0f );
 322    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 323
 324    draw_origin_axis();
 325
 326    if( sv_scene == 0 )
 327    {
 328       render_main_game();
 329    }
 330    else if( sv_scene == 1 )
 331    {
 332       physics_test_render();
 333    }
 334 }
 335
 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
 354 void vg_ui(void)
 355 {
 356    char buf[20];
 357
 358 #if 0
 359    snprintf( buf, 20, "%.2fm/s", v3_length( player.v ) );
 360    gui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 361
 362    snprintf( buf, 20, "%.2f %.2f %.2f m/s",
 363          player.a[0], player.a[1], player.a[2] );
 364    gui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 365
 366    snprintf( buf, 20, "pos %.2f %.2f %.2f",
 367          player.co[0], player.co[1], player.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, 20, "%.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 #endif
 384
 385    if( lightedit )
 386    {
 387       ui_global_ctx.cursor[0] = 10;
 388       ui_global_ctx.cursor[1] = 10;
 389       ui_global_ctx.cursor[2] = 200;
 390       ui_global_ctx.cursor[3] = 20;
 391
 392       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 393       struct ui_slider_vector
 394          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 395
 396       struct ui_slider
 397          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 398          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 399
 400       for( int i=0; i<3; i++ )
 401          run_light_widget( &gpipeline.widgets[i] );
 402
 403       gui_text( ui_global_ctx.cursor, "Ambient", 1, 0 );
 404       ui_global_ctx.cursor[1] += 16;
 405       ui_slider_vector( &ui_global_ctx, &s5 );
 406
 407       gui_text( ui_global_ctx.cursor, "Shadows", 1, 0 );
 408       ui_global_ctx.cursor[1] += 16;
 409       ui_slider( &ui_global_ctx, &s8 );
 410       ui_slider( &ui_global_ctx, &s9 );
 411
 412       gui_text( ui_global_ctx.cursor, "Misc", 1, 0 );
 413       ui_global_ctx.cursor[1] += 16;
 414       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 415       ui_checkbox( &ui_global_ctx, &c1 );
 416
 417       render_update_lighting_ub();
 418    }
 419 }