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