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