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