main.c

   1 #define VG_3D
   2 #include "vg/vg.h"
   3
   4 /* Resources */
   5 vg_tex2d tex_norwey = { .path = "textures/norway_foliage.qoi" };
   6 vg_tex2d tex_grid = { .path = "textures/grid.qoi" };
   7 vg_tex2d tex_sky = { .path = "textures/sky.qoi" };
   8 vg_tex2d tex_gradients = { .path = "textures/gradients.qoi",
   9                            .flags = VG_TEXTURE_CLAMP };
  10 vg_tex2d tex_cement = { .path = "textures/cement512.qoi" };
  11
  12 vg_tex2d *texture_list[] =
  13 {
  14    &tex_norwey,
  15    &tex_gradients,
  16    &tex_grid,
  17    &tex_sky,
  18    &tex_cement
  19 };
  20
  21 /* Convars */
  22 static int freecam = 0;
  23 static int debugview = 0;
  24 static int debugsdf = 0;
  25 static int sv_debugcam = 0;
  26
  27 /* Components */
  28 #include "road.h"
  29 #include "scene.h"
  30 #include "ik.h"
  31
  32 int main( int argc, char *argv[] )
  33 {
  34    vg_init( argc, argv, "Voyager Game Engine" );
  35 }
  36
  37 m4x3f world_matrix;
  38
  39 static struct gplayer
  40 {
  41    /* Physics */
  42    v3f co, v, a;
  43    v4f rot;
  44    float vswitch, slip_last;
  45
  46    float iY;   /* Yaw inertia */
  47    int in_air;
  48
  49    /* Input */
  50    v2f joy_l;
  51
  52    v3f view;
  53    v2f look_dir;  /* TEMP */
  54    float pitch;
  55
  56    m4x3f to_world, to_local;
  57
  58    v3f handl_target, handr_target,
  59        handl, handr;
  60
  61    glmesh mesh;
  62    submodel legl,
  63             legu,
  64             board,
  65             torso,
  66             wheels,
  67             feet;
  68 }
  69 player;
  70
  71 static struct gworld
  72 {
  73    glmesh skydome;
  74    glmesh cement;
  75
  76    scene foliage,    /* Tree shader */
  77          geo,        /* Std shader, collisions */
  78          detail;     /* Std shader, no collisions */
  79
  80    submodel terrain,
  81             terrain_rocks,
  82             terrain_road;
  83 }
  84 world;
  85
  86 static void player_transform_update(void)
  87 {
  88    q_m3x3( player.rot, player.to_world );
  89    v3_copy( player.co, player.to_world[3] );
  90
  91    v4f inv;
  92    q_inv( player.rot, inv );
  93    q_m3x3( inv, player.to_local );
  94    v3_negate( player.co, player.to_local[3] );
  95 }
  96
  97 static int reset_player( int argc, char const *argv[] )
  98 {
  99    v3_zero( player.co );
 100    v3_copy( (v3f){ 0.0f, 0.0f, -0.2f }, player.v );
 101    q_identity( player.rot );
 102    player.vswitch = 1.0f;
 103    player.slip_last = 0.0f;
 104
 105    player_transform_update();
 106    return 0;
 107 }
 108
 109 void vg_register(void)
 110 {
 111    scene_register();
 112 }
 113
 114 void vg_start(void)
 115 {
 116    vg_tex2d_init( texture_list, vg_list_size( texture_list ) );
 117
 118    vg_convar_push( (struct vg_convar){
 119       .name = "freecam",
 120       .data = &freecam,
 121       .data_type = k_convar_dtype_i32,
 122       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 123       .persistent = 1
 124    });
 125
 126    vg_convar_push( (struct vg_convar){
 127       .name = "debugcam",
 128       .data = &sv_debugcam,
 129       .data_type = k_convar_dtype_i32,
 130       .opt_i32 = { .min=0, .max=1, .clamp=0 },
 131       .persistent = 1
 132    });
 133
 134    vg_convar_push( (struct vg_convar){
 135       .name = "debugview",
 136       .data = &debugview,
 137       .data_type = k_convar_dtype_i32,
 138       .opt_i32 = { .min=0, .max=1, .clamp=0 },
 139       .persistent = 1
 140    });
 141
 142    vg_convar_push( (struct vg_convar){
 143       .name = "debugsdf",
 144       .data = &debugsdf,
 145       .data_type = k_convar_dtype_i32,
 146       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 147       .persistent = 1
 148    });
 149
 150         vg_function_push( (struct vg_cmd){
 151                 .name = "reset",
 152                 .function = reset_player
 153         });
 154
 155    v3f lightDir = { 0.1f, 0.8f, 0.2f };
 156    v3_normalize( lightDir );
 157
 158    /* Unpack player */
 159    model *char_dev = vg_asset_read( "models/char_dev.mdl" );
 160    model_unpack( char_dev, &player.mesh );
 161    player.legl = *submodel_get( char_dev, "legl" );
 162    player.legu = *submodel_get( char_dev, "legu" );
 163    player.board = *submodel_get( char_dev, "skateboard" );
 164    player.torso = *submodel_get( char_dev, "torso" );
 165    player.wheels = *submodel_get( char_dev, "wheels" );
 166    player.feet = *submodel_get( char_dev, "feet" );
 167    free(char_dev);
 168
 169    /* temp */
 170    model *cement_model = vg_asset_read("models/cement_r1.mdl" );
 171    model_unpack( cement_model, &world.cement );
 172    free( cement_model );
 173
 174    /* Setup scene */
 175    scene_init( &world.geo );
 176    scene_init( &world.detail );
 177    scene_init( &world.foliage );
 178
 179    model *mworld = vg_asset_read( "models/free_dev.mdl" );
 180    model *mtest = vg_asset_read( "models/test.mdl" );
 181
 182    model *msky = vg_asset_read( "models/skydome.mdl" );
 183    model_unpack( msky, &world.skydome );
 184    free( msky );
 185
 186    scene_add_model( &world.geo, mworld, submodel_get( mworld, "terrain" ),
 187          (v3f){0.0f,0.0f,0.0f}, 0.0f, 1.0f );
 188    scene_copy_slice( &world.geo, &world.terrain );
 189
 190    scene_add_model( &world.geo, mworld, submodel_get( mworld, "terrain_rocks" ),
 191          (v3f){0.0f,0.0f,0.0f}, 0.0f, 1.0f );
 192    scene_copy_slice( &world.geo, &world.terrain_rocks );
 193
 194    submodel *ptree = submodel_get( mtest, "tree" ),
 195             *pt_groundcover[] =
 196        {
 197          submodel_get( mtest, "bush" ),
 198          submodel_get( mtest, "bush" ),
 199          submodel_get( mtest, "blubber" ),
 200        };
 201
 202    /* Sprinkle some trees in the terrain areas */
 203    v3f range;
 204    v3_sub( world.geo.bbx[1], world.geo.bbx[0], range );
 205
 206 #ifdef VG_RELEASE
 207    int const ktree_count = 8000,
 208              kfoliage_count = 200000;
 209 #else
 210    int const ktree_count = 200,
 211              kfoliage_count = 0;
 212 #endif
 213
 214    for( int i=0; i<ktree_count; i++ )
 215    {
 216       v3f pos = { vg_randf(), 0.0f, vg_randf() },
 217           norm;
 218
 219       v3_muladd( world.geo.bbx[0], pos, range, pos );
 220
 221       if( sample_scene_height( &world.geo, pos, norm ) )
 222       {
 223          if( v3_dot( norm, (v3f){ 0.0f, 1.0f, 0.0f } ) > 0.9f )
 224          {
 225             scene_add_model( &world.foliage, mtest, ptree,
 226                   pos, vg_randf() * VG_TAUf, vg_randf() * 0.5f + 0.5f );
 227          }
 228       }
 229    }
 230
 231    for( int i=0; i<kfoliage_count; i++ )
 232    {
 233       v3f pos = { vg_randf(), 0.0f, vg_randf() },
 234           norm;
 235
 236       v3_muladd( world.geo.bbx[0], pos, range, pos );
 237
 238       if( sample_scene_height( &world.geo, pos, norm ) )
 239       {
 240          if( v3_dot( norm, (v3f){ 0.0f, 1.0f, 0.0f } ) > 0.7f )
 241          {
 242             scene_add_model( &world.foliage, mtest,
 243                   pt_groundcover[rand()%vg_list_size(pt_groundcover)],
 244                   pos, vg_randf() * VG_TAUf, vg_randf() * 0.5f + 0.5f );
 245          }
 246       }
 247    }
 248
 249    scene_add_model( &world.geo, mworld, submodel_get( mworld, "road" ),
 250          (v3f){0.0f,0.0f,0.0f}, 0.0f, 1.0f );
 251    scene_copy_slice( &world.geo, &world.terrain_road );
 252
 253    scene_add_model( &world.detail, mworld, submodel_get( mworld, "art" ),
 254          (v3f){0.0f,0.0f,0.0f}, 0.0f, 1.0f );
 255
 256    free( mtest );
 257    free( mworld );
 258
 259    scene_compute_occlusion( &world.foliage );
 260
 261    scene_upload( &world.foliage );
 262    scene_upload( &world.geo );
 263    scene_upload( &world.detail );
 264
 265    reset_player( 0, NULL );
 266    player_transform_update();
 267 }
 268
 269 static float ktimestep = 1.0f/60.0f;
 270
 271 static void player_freecam(void)
 272 {
 273    m4x3f cam_rot;
 274    m4x3_identity( cam_rot );
 275    m4x3_rotate_y( cam_rot, -player.look_dir[0] );
 276    m4x3_rotate_x( cam_rot, -player.look_dir[1] );
 277
 278    v3f lookdir = { 0.0f, 0.0f, -1.0f },
 279        sidedir = { 1.0f, 0.0f,  0.0f };
 280
 281    m4x3_mulv( cam_rot, lookdir, lookdir );
 282    m4x3_mulv( cam_rot, sidedir, sidedir );
 283
 284    float movespeed = 5.0f;
 285    static v2f mouse_last,
 286               view_vel = { 0.0f, 0.0f };
 287
 288    static v3f move_vel = { 0.0f, 0.0f, 0.0f };
 289
 290    if( vg_get_button_down( "primary" ) )
 291       v2_copy( vg_mouse, mouse_last );
 292    else if( vg_get_button( "primary" ) )
 293    {
 294       v2f delta;
 295       v2_sub( vg_mouse, mouse_last, delta );
 296       v2_copy( vg_mouse, mouse_last );
 297
 298       v2_muladds( view_vel, delta, 0.005f, view_vel );
 299    }
 300
 301    v2_muls( view_vel, 0.75f, view_vel );
 302    v2_add( view_vel, player.look_dir, player.look_dir );
 303    player.look_dir[1] =
 304       vg_clampf( player.look_dir[1], -VG_PIf*0.5f, VG_PIf*0.5f );
 305
 306    if( vg_get_button( "forward" ) )
 307       v3_muladds( move_vel, lookdir, ktimestep * movespeed, move_vel );
 308    if( vg_get_button( "back" ) )
 309       v3_muladds( move_vel, lookdir, ktimestep *-movespeed, move_vel );
 310    if( vg_get_button( "left" ) )
 311       v3_muladds( move_vel, sidedir, ktimestep *-movespeed, move_vel );
 312    if( vg_get_button( "right" ) )
 313       v3_muladds( move_vel, sidedir, ktimestep * movespeed, move_vel );
 314
 315    v3_muls( move_vel, 0.75f, move_vel );
 316    v3_add( move_vel, player.view, player.view );
 317 }
 318
 319 static void apply_gravity( v3f vel, float const timestep )
 320 {
 321    v3f gravity = { 0.0f, -9.6f, 0.0f };
 322    v3_muladds( vel, gravity, timestep, vel );
 323 }
 324
 325 static void player_physics_ground(void)
 326 {
 327    /*
 328     * Getting surface collision points,
 329     * the contact manifold is a triangle for simplicity.
 330     */
 331    v3f contact_front, contact_back, fwd, fwd1, contact_norm, vup, vside,
 332        axis;
 333
 334    m3x3_mulv( player.to_world, (v3f){0.0f,0.0f,-1.0f}, fwd );
 335    m4x3_mulv( player.to_world, (v3f){ 0.15f,0.0f,-1.0f}, contact_norm );
 336    m4x3_mulv( player.to_world, (v3f){-0.15f,0.0f,-1.0f}, contact_front );
 337    m4x3_mulv( player.to_world, (v3f){ 0.00f,0.0f, 1.0f}, contact_back );
 338    m3x3_mulv( player.to_world, (v3f){0.0f,1.0f,0.0f}, vup );
 339    m3x3_mulv( player.to_world, (v3f){1.0f,0.0f,0.0f}, vside );
 340
 341    int all_contacting =
 342       sample_scene_height( &world.geo, contact_front, NULL ) &&
 343       sample_scene_height( &world.geo, contact_back, NULL ) &&
 344       sample_scene_height( &world.geo, contact_norm, NULL );
 345
 346    if( !all_contacting )
 347    {
 348       player.in_air = 1;
 349       return;
 350    }
 351
 352    v3f norm;
 353    v3f v0, v1;
 354    v3_sub( contact_norm, contact_front, v0 );
 355    v3_sub( contact_back, contact_front, v1 );
 356    v3_cross( v1, v0, norm );
 357    v3_normalize( norm );
 358
 359    vg_line( contact_norm, contact_front, 0xff00ff00 );
 360    vg_line( contact_back, contact_front, 0xff0000ff );
 361
 362    /* Surface alignment */
 363    float angle = v3_dot( vup, norm );
 364    v3_cross( vup, norm, axis );
 365
 366    if( angle < 0.999f )
 367    {
 368       v4f correction;
 369       q_axis_angle( correction, axis, acosf(angle) );
 370       q_mul( correction, player.rot, player.rot );
 371    }
 372
 373    float resistance = v3_dot( norm, player.v );
 374
 375    if( resistance >= 0.0f )
 376    {
 377       player.in_air = 1;
 378       return;
 379    }
 380    else
 381    {
 382       v3_muladds( player.v, norm, -resistance, player.v );
 383    }
 384
 385    /* This is where velocity integration used to be */
 386
 387    float slip = 0.0f;
 388
 389    player.co[1] = (contact_front[1]+contact_back[1])*0.5f;
 390
 391    v3f vel;
 392    m3x3_mulv( player.to_local, player.v, vel );
 393
 394    /* Calculate local forces */
 395
 396    slip = (-vel[0] / vel[2]) * player.vswitch;
 397    if( fabsf( slip ) > 1.2f )
 398       slip = vg_signf( slip ) * 1.2f;
 399
 400
 401    if( player.slip_last*slip < 0.0f && fabsf(slip) > 0.7f )
 402    {
 403       vg_warn( "SWITCH\n" );
 404       player.vswitch = -player.vswitch;
 405       slip = -slip;
 406    }
 407
 408    player.slip_last = slip;
 409
 410    float substep = ktimestep * 0.2f;
 411
 412    for( int i=0; i<5; i++ )
 413    {
 414       if( fabsf(vel[2]) >= 0.02f*substep )
 415          vel[2] += vg_signf( vel[2] ) * -0.02f * substep;
 416       if( fabsf(vel[0]) >= 7.0f*substep )
 417          vel[0] += vg_signf( vel[0] ) * -7.0f * substep;
 418    }
 419
 420    m3x3_mulv( player.to_world, vel, player.v );
 421
 422    if( vg_get_button( "yawl" ) )
 423       player.iY +=  3.6f * ktimestep;
 424    if( vg_get_button( "yawr" ) )
 425       player.iY -=  3.6f * ktimestep;
 426
 427    float steer = vg_get_axis( "horizontal" );
 428    player.iY -= vg_signf(steer)*powf(steer,2.0f) * 3.5f * ktimestep;
 429 }
 430
 431 static void player_physics_air(void)
 432 {
 433    v3f ground_pos, ground_norm;
 434    v3_copy( player.co, ground_pos );
 435
 436    if( sample_scene_height( &world.geo, ground_pos, ground_norm ) )
 437    {
 438       if( ground_pos[1] > player.co[1] )
 439       {
 440          player.in_air = 0;
 441          return;
 442       }
 443    }
 444
 445    /* Prediction
 446     *
 447     * TODO: Find best landing surface and guide player towords it
 448     */
 449    float pstep = ktimestep*10.0f;
 450
 451    v3f pco, pco1, pv;
 452    v3_copy( player.co, pco );
 453    v3_copy( player.v, pv );
 454
 455    v3f targetn;
 456    for( int i=0; i<50; i++ )
 457    {
 458       v3_copy( pco, pco1 );
 459       apply_gravity( pv, pstep );
 460       v3_muladds( pco, pv, pstep, pco );
 461
 462       vg_line( pco, pco1, i&0x1?0xff000000:0xffffffff );
 463
 464       v3f sh;
 465       v3_copy( pco, sh );
 466       int hit = sample_scene_height( &world.geo, sh, targetn );
 467
 468       if( sh[1] >= pco[1] && hit )
 469       {
 470          v3f localup;
 471          m3x3_mulv( player.to_world, (v3f){0.0f,1.0f,0.0f}, localup );
 472
 473          float angle = v3_dot( localup, targetn );
 474          v3f axis;
 475          v3_cross( localup, targetn, axis );
 476
 477          if( angle < 0.99f )
 478          {
 479             v4f correction;
 480             q_axis_angle( correction, axis, acosf(angle)*0.01f );
 481             q_mul( correction, player.rot, player.rot );
 482          }
 483
 484          break;
 485       }
 486    }
 487
 488    player.iY -= vg_get_axis( "horizontal" ) * 3.6f * ktimestep;
 489 }
 490
 491 static void player_update(void)
 492 {
 493    /* temp */
 494    if( vg_get_axis("grabl")>0.0f)
 495       reset_player(0,NULL);
 496    if( vg_get_button( "forward" ) )
 497    {
 498       v3f dir = { 0.0f, 0.0f, -1.0f };
 499
 500       m3x3_mulv( player.to_world, dir, dir );
 501       v3_muladds( player.v, dir, 5.0f * ktimestep, player.v );
 502    }
 503
 504
 505    float horizontal = vg_get_axis("horizontal"),
 506          vertical = vg_get_axis("vertical");
 507
 508    player.joy_l[0] = vg_signf(horizontal) * powf( horizontal, 2.0f );
 509    player.joy_l[1] = vg_signf(vertical) * powf( vertical, 2.0f );
 510
 511    if( freecam )
 512    {
 513       player_freecam();
 514       return;
 515    }
 516
 517    /* Integrate velocity */
 518    apply_gravity( player.v, ktimestep );
 519    v3_muladds( player.co, player.v, ktimestep, player.co );
 520
 521    /* Integrate inertia */
 522    v4f rotate; v3f vup = {0.0f,1.0f,0.0f};
 523    m3x3_mulv( player.to_world, vup, vup );
 524
 525    q_axis_angle( rotate, vup, player.iY );
 526    q_mul( rotate, player.rot, player.rot );
 527
 528    player.look_dir[0] = atan2f( player.v[0], -player.v[2] );
 529    player.look_dir[1] = atan2f( -player.v[1], sqrtf(player.v[0]*player.v[0]+
 530                                        player.v[2]*player.v[2]) ) * 0.3f;
 531
 532    player.iY = 0.0f; /* temp */
 533
 534    if( player.in_air )
 535       player_physics_air();
 536
 537    if( !player.in_air )
 538       player_physics_ground();
 539
 540    /* Camera and character */
 541    float kheight = 1.8f,
 542          kleg = 0.6f;
 543
 544    v3f head;
 545    head[0] =  0.0f;
 546    head[1] =  kheight;
 547    head[2] =  0.0f;
 548
 549    m4x3_mulv( player.to_world, head, head );
 550    v3_copy( head, player.view );
 551
 552    player_transform_update();
 553    q_normalize(player.rot);
 554 }
 555
 556 void vg_update(void)
 557 {
 558    player_update();
 559
 560    /* Creating a skeleton of the player dynamically */
 561
 562    v2f ac;
 563
 564    static v3f last_vel = { 0.0f, 0.0f, 0.0f };
 565    static v3f momentum, bob;
 566
 567    v3_sub( player.v, last_vel, player.a );
 568    v3_copy( player.v, last_vel );
 569
 570    v3_add( momentum, player.a, momentum );
 571
 572    v3_lerp( momentum, (v3f){0.0f,0.0f,0.0f}, 0.1f, momentum );
 573    v3f target;
 574
 575    momentum[0] = vg_clampf( momentum[0], -2.0f, 2.0f );
 576    momentum[1] = vg_clampf( momentum[1], -0.2f, 5.0f );
 577    momentum[2] = vg_clampf( momentum[2], -2.0f, 2.0f );
 578    v3_copy( momentum, target );
 579
 580    v3_lerp( bob, target, 0.2f, bob );
 581
 582    /* Head */
 583 #if 0
 584    float lslip = fabsf(slip); //vg_minf( 0.4f, slip );
 585
 586    static float grab = 0.0f;
 587    float grabt = vg_get_axis( "grabr" )*0.5f+0.5f;
 588    grab = vg_lerpf( grab, grabt, 0.04f );
 589
 590    v3f head;
 591    head[0] =  0.0f;//(-sinf(lslip)*0.9f * kheight) * 0.44f;
 592    head[1] =  (0.3f + cosf(lslip)*0.5f) * kheight - grab*0.7f;
 593    head[2] =  0.0f;
 594
 595    v3f offset;
 596    m3x3_mulv( player.to_local, bob, offset );
 597    offset[0] *= 0.25f;
 598    offset[1] *= -0.25f;
 599    offset[2] *= 0.7f;
 600    v3_muladds( head, offset, 0.7f, head );
 601
 602    head[1] = vg_clampf( head[1], 0.3f, 20.0f );
 603
 604    player.handl_target[0] = head[0] + 0.2f;
 605    player.handl_target[1] = head[1] - 0.8f*(1.0f-fabsf(slip));
 606    player.handl_target[2] = head[2] + 0.2f + 0.7f*fabsf(slip);
 607
 608    player.handr_target[0] = head[0] + 0.2f;
 609    player.handr_target[1] = head[1] - 0.8f*(1.0f-fabsf(slip));
 610    player.handr_target[2] = head[2] - (0.2f + 0.7f*fabsf(slip));
 611
 612    if( vg_maxf(lslip,grab) > 0.5f )
 613    {
 614       if( slip < 0.0f && in_air )
 615       {
 616          player.handl_target[0] = 0.15f;
 617          player.handl_target[1] = 0.1f;
 618          player.handl_target[2] = 0.4f;
 619       }
 620       else
 621       {
 622          player.handr_target[0] =  0.15f;
 623          player.handr_target[1] =  0.1f;
 624          player.handr_target[2] = -0.4f;
 625       }
 626
 627       if( grab > 0.5f )
 628       {
 629          player.handr_target[0] =  -0.15f;
 630          player.handr_target[1] =  0.1f;
 631          player.handr_target[2] =  0.4f;
 632       }
 633    }
 634 #endif
 635
 636 }
 637
 638 static void debug_grid( v3f at )
 639 {
 640    v3f base;
 641    v3_floor( at, base );
 642
 643    for( int y=0; y<16; y++ )
 644    {
 645       vg_line( (v3f){ base[0] - 8, base[1], base[2]+y-8 },
 646                (v3f){ base[0] + 8, base[1], base[2]+y-8 },
 647                0x40ffffff );
 648    }
 649    for( int x=0; x<16; x++ )
 650    {
 651       vg_line( (v3f){ base[0]+x-8, base[1], base[2]-8 },
 652                (v3f){ base[0]+x-8, base[1], base[2]+8 },
 653                0x40ffffff );
 654    }
 655 }
 656
 657 static void draw_player(void)
 658 {
 659    mesh_bind( &player.mesh );
 660    float const kleg_upper = 0.53f,
 661                kleg_lower = 0.5f,
 662                karm_ratio = 0.75f,
 663                karm_upper = kleg_upper*karm_ratio,
 664                karm_lower = kleg_lower*karm_ratio;
 665
 666    /* Create IK targets */
 667    struct ik_basic ik_leg_l = { .l1 = kleg_upper, .l2 = kleg_lower },
 668                    ik_leg_r = { .l1 = kleg_upper, .l2 = kleg_lower },
 669                    ik_arm_l = { .l1 = karm_upper, .l2 = karm_lower },
 670                    ik_arm_r = { .l1 = karm_upper, .l2 = karm_lower };
 671
 672    v3f butt, fwd;
 673
 674    m4x3_mulv( player.to_world, (v3f){ 0.0f,0.16f,-0.4f }, ik_leg_r.end );
 675    m4x3_mulv( player.to_world, (v3f){ 0.0f,0.16f, 0.3f }, ik_leg_l.end );
 676    m4x3_mulv( player.to_world, (v3f){ -0.6f,0.5f,-0.4f }, ik_leg_r.pole );
 677    m4x3_mulv( player.to_world, (v3f){ -0.6f,0.5f,0.35f }, ik_leg_l.pole );
 678
 679    m3x3_mulv( player.to_world, (v3f){ 0.2f,-0.55f,0.0f}, butt );
 680    v3_add( butt, player.view, butt );
 681
 682    m3x3_mulv( player.to_world, (v3f){0.0f,0.0f,-1.0f}, fwd );
 683    v3_muladds( butt, fwd, 0.1f, ik_leg_r.base );
 684    v3_muladds( butt, fwd,-0.1f, ik_leg_l.base );
 685
 686    /* Compute IK */
 687    m4x3f mleg_l, mknee_l, mleg_r, mknee_r, mboard;
 688
 689    ik_basic( &ik_leg_r, mleg_r, mknee_r );
 690    ik_basic( &ik_leg_l, mleg_l, mknee_l );
 691
 692    /* Arms */
 693    v3f hl, hr, neckl = {0.2f,-0.1f, 0.2f},
 694                neckr = {0.2f,-0.1f,-0.2f};
 695
 696    v3_lerp( player.handl, player.handl_target, 0.04f, player.handl );
 697    v3_lerp( player.handr, player.handr_target, 0.04f, player.handr );
 698
 699    m3x3_mulv( player.to_world, neckl, neckl );
 700    m3x3_mulv( player.to_world, neckr, neckr );
 701
 702    v3_add( player.view, neckl, ik_arm_l.base );
 703    v3_add( player.view, neckr, ik_arm_r.base );
 704    m4x3_mulv( player.to_world, player.handl, ik_arm_l.end );
 705    m4x3_mulv( player.to_world, player.handr, ik_arm_r.end );
 706    m4x3_mulv( player.to_world, (v3f){ 0.6f,0.7f, 0.4f  }, ik_arm_l.pole );
 707    m4x3_mulv( player.to_world, (v3f){ 0.6f,0.7f,-0.35f }, ik_arm_r.pole );
 708
 709    m4x3f marm_l, melbow_l, marm_r, melbow_r;
 710    ik_basic( &ik_arm_l, marm_l, melbow_l );
 711    ik_basic( &ik_arm_r, marm_r, melbow_r );
 712    m4x3_scale( marm_l, karm_ratio );
 713    m4x3_scale( marm_r, karm_ratio );
 714    m4x3_scale( melbow_l, karm_ratio );
 715    m4x3_scale( melbow_r, karm_ratio );
 716
 717    /* Draw */
 718    vg_tex2d_bind( &tex_grid, 0 );
 719    scene_tree_sway = 0.0f;
 720
 721    mesh_bind( &player.mesh );
 722    m4x4f mat;
 723
 724    SHADER_USE(shader_standard_lit);
 725
 726         glUniformMatrix4fv( SHADER_UNIFORM( shader_standard_lit, "uPv" ),
 727          1, GL_FALSE, (float *)vg_pv );
 728    glUniform1i( SHADER_UNIFORM( shader_standard_lit, "uTexMain" ), 0 );
 729    vg_tex2d_bind( &tex_grid, 0 );
 730
 731    GLint kuMdl = SHADER_UNIFORM( shader_standard_lit, "uMdl" );
 732
 733    float kscale = 0.7f;
 734    glUniform4f( SHADER_UNIFORM(shader_standard_lit,"uColour"),
 735          0.35f*kscale,0.35f*kscale,0.35f*kscale,1.0f );
 736
 737    m4x3_expand( player.to_world, mat );
 738         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 739    submodel_draw( &player.board );
 740
 741    glUniform4f( SHADER_UNIFORM(shader_standard_lit,"uColour"),
 742          0.7f*kscale,0.7f*kscale,0.7f*kscale,1.0f );
 743    submodel_draw( &player.wheels );
 744
 745    glEnable(GL_BLEND);
 746    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 747    glBlendEquation(GL_FUNC_ADD);
 748    glDisable( GL_DEPTH_TEST );
 749    glUniform4f( SHADER_UNIFORM(shader_standard_lit,"uColour"),
 750          0.2f*kscale,0.8f*kscale,0.4f*kscale,0.14f );
 751
 752    submodel_draw( &player.feet );
 753
 754    m4x3_expand( mleg_l, mat );
 755         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 756    submodel_draw( &player.legu );
 757
 758    m4x3_expand( mknee_l, mat );
 759         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 760    submodel_draw( &player.legl );
 761
 762    m4x3_expand( mleg_r, mat );
 763         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 764    submodel_draw( &player.legu );
 765
 766    m4x3_expand( mknee_r, mat );
 767         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 768    submodel_draw( &player.legl );
 769
 770    /* arms */
 771    m4x3_expand( marm_l, mat );
 772         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 773    submodel_draw( &player.legu );
 774
 775    m4x3_expand( melbow_l, mat );
 776         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 777    submodel_draw( &player.legl );
 778
 779    m4x3_expand( marm_r, mat );
 780         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 781    submodel_draw( &player.legu );
 782
 783    m4x3_expand( melbow_r, mat );
 784         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 785    submodel_draw( &player.legl );
 786
 787    /* body */
 788    m4x3f mbutt;
 789    m3x3_copy( player.to_world, mbutt );
 790    v3_copy( butt, mbutt[3] );
 791
 792    m4x3_expand( mbutt, mat );
 793         glUniformMatrix4fv( kuMdl, 1, GL_FALSE, (float *)mat );
 794    submodel_draw( &player.torso );
 795
 796    glDisable(GL_BLEND);
 797    glEnable( GL_DEPTH_TEST );
 798 }
 799
 800 void vg_render(void)
 801 {
 802    glViewport( 0,0, vg_window_x, vg_window_y );
 803
 804    glDisable( GL_DEPTH_TEST );
 805    glClearColor( 0.1f, 0.0f, 0.2f, 1.0f );
 806    glClearColor(141.0f/255.0f, 176.0f/255.0f, 215.0f/255.0f,1.0f);
 807    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 808
 809    v3f pos_inv;
 810    v3_negate( player.view, pos_inv );
 811
 812    float speed = v3_length( player.v );
 813    v3f shake = { vg_randf()-0.5f, vg_randf()-0.5f, vg_randf()-0.5f };
 814    v3_muls( shake, speed*0.01f, shake );
 815
 816    static v2f look_lerped = {0.0f,0.0f};
 817    v2_lerp( look_lerped, player.look_dir, 0.03f, look_lerped );
 818
 819    m4x3_identity( world_matrix );
 820    m4x3_rotate_x( world_matrix,
 821          freecam? look_lerped[1]: 0.6f+shake[1]*0.04f+look_lerped[1] );
 822
 823    m4x3_rotate_y( world_matrix, look_lerped[0]+shake[0]*0.02f );
 824    m4x3_translate( world_matrix, pos_inv );
 825
 826    m4x4f world_4x4;
 827    m4x3_expand( world_matrix, world_4x4 );
 828
 829    m4x4_projection( vg_pv,
 830          freecam? 90.0f: 130.0f,
 831          (float)vg_window_x / (float)vg_window_y,
 832          0.01f, 1000.0f );
 833    m4x4_mul( vg_pv, world_4x4, vg_pv );
 834
 835    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 836    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 837    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 838
 839    glEnable( GL_DEPTH_TEST );
 840
 841    scene_foliage_shader_use();
 842    m4x4f temp1;
 843    m4x4_identity( temp1 );
 844         glUniformMatrix4fv( SHADER_UNIFORM( shader_debug_vcol, "uMdl" ),
 845          1, GL_FALSE, (float *)temp1 );
 846
 847    vg_tex2d_bind( &tex_norwey, 0 );
 848    scene_tree_sway = 0.1f;
 849
 850    scene_bind( &world.foliage );
 851    scene_draw( &world.foliage );
 852    if( debugsdf )
 853       scene_debugsdf( &world.foliage );
 854
 855    SHADER_USE(shader_unlit);
 856    m4x4f temp2;
 857    m4x4_identity(temp2);
 858    //m4x4_translate( temp2, player.co );
 859         glUniformMatrix4fv( SHADER_UNIFORM( shader_unlit, "uMdl" ),
 860          1, GL_FALSE, (float *)temp2 );
 861         glUniformMatrix4fv( SHADER_UNIFORM( shader_unlit, "uPv" ),
 862          1, GL_FALSE, (float *)vg_pv );
 863
 864    glUniform1i( SHADER_UNIFORM( shader_unlit, "uTexMain" ), 0 );
 865    vg_tex2d_bind( &tex_sky, 0 );
 866
 867    mesh_bind( &world.skydome );
 868    mesh_draw( &world.skydome );
 869
 870    vg_tex2d_bind( &tex_cement, 0 );
 871    mesh_bind( &world.cement );
 872    mesh_draw( &world.cement );
 873
 874    SHADER_USE(shader_standard_lit);
 875
 876         glUniformMatrix4fv( SHADER_UNIFORM( shader_standard_lit, "uPv" ),
 877          1, GL_FALSE, (float *)vg_pv );
 878    glUniform1i( SHADER_UNIFORM( shader_standard_lit, "uTexMain" ), 0 );
 879
 880         glUniformMatrix4fv( SHADER_UNIFORM( shader_standard_lit, "uMdl" ),
 881          1, GL_FALSE, (float *)temp1 );
 882
 883    vg_tex2d_bind( &tex_grid, 0 );
 884
 885    scene_bind( &world.geo );
 886 #if 0
 887    glUniform4f( SHADER_UNIFORM(shader_standard_lit,"uColour"),
 888          0.2f,0.36f,0.25f,1.0f );
 889    submodel_draw( &world.terrain );
 890
 891    glUniform4f( SHADER_UNIFORM(shader_standard_lit,"uColour"),
 892          0.2f,0.2f,0.21f,1.0f );
 893    submodel_draw( &world.terrain_rocks );
 894    glUniform4f( SHADER_UNIFORM(shader_standard_lit,"uColour"),
 895          0.4f,0.4f,0.4f,1.0f );
 896    submodel_draw( &world.terrain_road );
 897 #endif
 898
 899    scene_bind( &world.detail );
 900    scene_draw( &world.detail );
 901
 902    draw_player();
 903
 904    glDisable( GL_DEPTH_TEST );
 905    vg_lines_drawall( (float *)vg_pv );
 906
 907    /* Debugger camera */
 908    glViewport( 0,0, 512, 512 );
 909    glClearColor( 0.1f, 0.0f, 0.2f, 1.0f );
 910    glClear( GL_DEPTH_BUFFER_BIT );
 911
 912    m4x3_identity( world_matrix );
 913
 914    v3f debugcam;
 915    v3_negate( player.co, debugcam );
 916    debugcam[2] -= 2.0f;
 917    debugcam[1] -= 0.7f;
 918
 919    m4x3_translate( world_matrix, debugcam );
 920    m4x3_expand( world_matrix, world_4x4 );
 921
 922    m4x4_projection( vg_pv,
 923          100.0f,
 924          (float)128.0f / (float)128.0f,
 925          0.01f, 1000.0f );
 926    m4x4_mul( vg_pv, world_4x4, vg_pv );
 927
 928    if(sv_debugcam)
 929    {
 930       glEnable( GL_DEPTH_TEST );
 931       draw_player();
 932    }
 933
 934    glDisable( GL_DEPTH_TEST );
 935    vg_lines_drawall( (float *)vg_pv );
 936
 937    glViewport( 0,0, vg_window_x, vg_window_y );
 938 }
 939
 940 void vg_ui(void)
 941 {
 942    char buf[20];
 943
 944    snprintf( buf, 20, "%.2fm/s", v3_length( player.v ) );
 945    gui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 946
 947    snprintf( buf, 20, "%.2f %.2f %.2f m/s",
 948          player.a[0], player.a[1], player.a[2] );
 949
 950    gui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 951
 952    if( vg_gamepad_ready )
 953    {
 954       for( int i=0; i<6; i++ )
 955       {
 956          snprintf( buf, 20, "%.2f", vg_gamepad.axes[i] );
 957          gui_text( (ui_px [2]){ 0, (i+2)*20 }, buf, 1, k_text_align_left );
 958       }
 959    }
 960    else
 961    {
 962       gui_text( (ui_px [2]){ 0, 40 },
 963             "Gamepad not ready", 1, k_text_align_left );
 964    }
 965 }
 966
 967 void vg_free(void){}