player.h

   1 #ifndef PLAYER_H
   2 #define PLAYER_H
   3
   4 #include "player_api.h"
   5
   6 #include "player_common.h"
   7 #include "player_walk.h"
   8 #include "player_skate.h"
   9 #include "player_dead.h"
  10
  11 struct player_instance
  12 {
  13    /* transform definition */
  14    rigidbody rb;
  15    v3f angles;
  16
  17    v4f   qbasis;
  18    m3x3f basis, invbasis, basis_gate;
  19    world_instance *viewable_world;
  20
  21    /*
  22     * Camera management
  23     * ---------------------------
  24     */
  25    camera cam; /* output final camera */
  26
  27    enum camera_mode
  28    {
  29       k_cam_firstperson = 0,
  30       k_cam_thirdperson = 1
  31    }
  32    camera_mode;
  33    float camera_type_blend;
  34
  35
  36    v3f fpv_offset,         /* expressed relative to rigidbody */
  37        tpv_offset,
  38        fpv_viewpoint,      /* expressed relative to neck bone inverse final */
  39        fpv_offset_smooth,
  40        fpv_viewpoint_smooth,
  41        tpv_offset_smooth,
  42        tpv_lpf,
  43        cam_velocity_smooth;
  44
  45    float cam_velocity_influence,
  46          cam_velocity_coefficient,
  47          cam_velocity_constant,
  48          cam_velocity_coefficient_smooth,
  49          cam_velocity_constant_smooth,
  50          cam_velocity_influence_smooth,
  51          cam_land_punch,
  52          cam_land_punch_v;
  53
  54    ent_gate *gate_waiting;
  55
  56    /*
  57     * Input
  58     * --------------------------------
  59     */
  60    struct input_binding *input_js1h,
  61                         *input_js1v,
  62                         *input_js2h,
  63                         *input_js2v,
  64                         *input_jump,
  65                         *input_push,
  66                         *input_trick0,
  67                         *input_trick1,
  68                         *input_trick2,
  69                         *input_walk,
  70                         *input_walkh,
  71                         *input_walkv,
  72                         *input_use,
  73                         *input_reset,
  74                         *input_grab,
  75                         *input_camera;
  76
  77    /*
  78     * Animation
  79     * --------------------------------------------------
  80     */
  81
  82    struct player_avatar  *playeravatar;
  83    glmesh                *playermesh;
  84    struct player_ragdoll  ragdoll;
  85    vg_tex2d              *playertex;
  86
  87    player_pose            holdout_pose;
  88    float                  holdout_time;
  89
  90    /*
  91     * Subsystems
  92     * -------------------------------------------------
  93     */
  94
  95    enum player_subsystem
  96    {
  97       k_player_subsystem_walk = 0,
  98       k_player_subsystem_skate = 1,
  99       k_player_subsystem_dead = 2
 100    }
 101    subsystem;
 102
 103    struct player_skate  _skate;
 104    struct player_walk   _walk;
 105    struct player_dead   _dead;
 106 };
 107
 108 /*
 109  * Gameloop tables
 110  * ---------------------------------------------------------
 111  */
 112
 113 VG_STATIC
 114 void (*_player_bind[])( player_instance *player ) =
 115 {
 116    player__walk_bind,
 117    player__skate_bind,
 118    NULL
 119 };
 120
 121 VG_STATIC
 122 void (*_player_reset[])( player_instance *player, ent_spawn *rp ) =
 123 {
 124    player__walk_reset,
 125    player__skate_reset,
 126    NULL
 127 };
 128
 129 VG_STATIC
 130 void (*_player_pre_update[])( player_instance *player ) =
 131 {
 132    player__walk_pre_update,
 133    player__skate_pre_update,
 134    NULL
 135 };
 136
 137 VG_STATIC
 138 void( *_player_update[])( player_instance *player ) =
 139 {
 140    player__walk_update,
 141    player__skate_update,
 142    player__dead_update,
 143 };
 144
 145 VG_STATIC
 146 void( *_player_post_update[])( player_instance *player ) =
 147 {
 148    player__walk_post_update,
 149    player__skate_post_update,
 150    NULL
 151 };
 152
 153 VG_STATIC
 154 void( *_player_im_gui[])( player_instance *player ) =
 155 {
 156    player__walk_im_gui,
 157    player__skate_im_gui,
 158    NULL
 159 };
 160
 161 VG_STATIC
 162 void( *_player_animate[])( player_instance *player, player_animation *dest ) =
 163 {
 164    player__walk_animate,
 165    player__skate_animate,
 166    player__dead_animate
 167 };
 168
 169 VG_STATIC
 170 void( *_player_post_animate[])( player_instance *player ) =
 171 {
 172    player__walk_post_animate,
 173    player__skate_post_animate,
 174    player__dead_post_animate
 175 };
 176
 177 /* implementation */
 178
 179 #include "player.c"
 180 #include "player_common.c"
 181 #include "player_walk.c"
 182 #include "player_skate.c"
 183 #include "player_dead.c"
 184
 185 #endif /* PLAYER_H */
 186
 187
 188 #if 0
 189 /*
 190  * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
 191  */
 192
 193 #define PLAYER_H
 194 #ifndef PLAYER_H
 195 #define PLAYER_H
 196
 197 #define PLAYER_REWIND_FRAMES 60*4
 198
 199 #include "conf.h"
 200 #include "audio.h"
 201 #include "common.h"
 202 #include "world.h"
 203 #include "skeleton.h"
 204 #include "bvh.h"
 205
 206
 207 /*
 208  * -----------------------------------------------------------------------------
 209  *                                  Memory
 210  * -----------------------------------------------------------------------------
 211  */
 212
 213 VG_STATIC struct gplayer
 214 {
 215    rigidbody rb, rb_frame;
 216    v3f co, angles;         /* used as transfer between controllers */
 217
 218    enum player_controller
 219    {
 220       k_player_controller_walk,
 221       k_player_controller_skate,
 222       k_player_controller_ragdoll,
 223       k_player_controller_mountain_skate,
 224       k_player_controller_snowboard,
 225       k_player_controller_drive
 226    }
 227    controller,
 228    controller_frame;
 229
 230    m4x3f visual_transform,
 231          inv_visual_transform;
 232
 233    int is_dead, death_tick_allowance, rewinding;
 234    int rewind_sound_wait;
 235
 236
 237    v3f handl_target, handr_target,
 238        handl, handr;
 239
 240    /* Input */
 241    struct input_binding *input_js1h,
 242                         *input_js1v,
 243                         *input_js2h,
 244                         *input_js2v,
 245                         *input_jump,
 246                         *input_push,
 247                         *input_walk,
 248                         *input_walkh,
 249                         *input_walkv,
 250                         *input_switch_mode,
 251                         *input_reset,
 252                         *input_grab;
 253
 254    /* Camera */
 255    float air_time;
 256    v3f camera_pos, smooth_localcam;
 257
 258    struct rewind_frame
 259    {
 260       v3f pos;
 261       v3f ang;
 262    }
 263    *rewind_buffer;
 264    u32 rewind_incrementer,
 265        rewind_length;
 266
 267    float rewind_time, rewind_total_length, rewind_predicted_time;
 268    double diag_rewind_start, diag_rewind_time;
 269    float dist_accum;
 270
 271    /* animation */
 272    double jump_time;
 273    float fslide,
 274          fdirz, fdirx,
 275          fstand,
 276          ffly,
 277          fpush,
 278          fairdir,
 279          fsetup,
 280          walk_timer,
 281          fjump,
 282          fonboard,
 283          frun,
 284          fgrind;
 285
 286    v3f board_offset;
 287    v4f board_rotation;
 288
 289    float walk;
 290    int step_phase;
 291    enum mdl_surface_prop surface_prop;
 292
 293    /* player model */
 294    struct player_model
 295    {
 296       glmesh player_meshes[3];
 297
 298       mdl_context meta;
 299       struct skeleton sk;
 300       struct skeleton_anim *anim_stand,
 301                            *anim_highg,
 302                            *anim_slide,
 303                            *anim_air,
 304                            *anim_push, *anim_push_reverse,
 305                            *anim_ollie, *anim_ollie_reverse,
 306                            *anim_grabs, *anim_stop,
 307                            *anim_walk, *anim_run, *anim_idle,
 308                            *anim_jump;
 309
 310       u32 id_hip,
 311           id_ik_hand_l,
 312           id_ik_hand_r,
 313           id_ik_elbow_l,
 314           id_ik_elbow_r,
 315           id_head,
 316           id_ik_foot_l,
 317           id_ik_foot_r,
 318           id_board;
 319
 320       v3f cam_pos;
 321
 322       struct ragdoll_part
 323       {
 324          u32 bone_id;
 325          //v3f offset;
 326
 327          /* Collider transform relative to bone */
 328          m4x3f collider_mtx,
 329                inv_collider_mtx;
 330
 331          u32 use_limits;
 332          v3f limits[2];
 333
 334          rigidbody  rb;
 335          u32 parent;
 336          u32 colour;
 337       }
 338       ragdoll[32];
 339       u32 ragdoll_count;
 340
 341       rb_constr_pos  position_constraints[32];
 342       u32            position_constraints_count;
 343
 344       rb_constr_swingtwist cone_constraints[32];
 345       u32                  cone_constraints_count;
 346
 347       int shoes[2];
 348    }
 349    mdl;
 350 }
 351 player__OLD
 352
 353 #if 0
 354 =
 355 {
 356    .collide_front = { .type = k_rb_shape_sphere, .inf.sphere.radius = 0.3f },
 357    .collide_back  = { .type = k_rb_shape_sphere, .inf.sphere.radius = 0.3f }
 358 }
 359 #endif
 360
 361 ;
 362
 363 /*
 364  * API
 365  */
 366 VG_STATIC float *player_get_pos(void);
 367 VG_STATIC void player_kill(void);
 368 VG_STATIC float *player_cam_pos(void);
 369 VG_STATIC void player_save_frame(void);
 370 VG_STATIC void player_restore_frame(void);
 371 VG_STATIC void player_save_rewind_frame(void);
 372
 373 /*
 374  * Submodules
 375  */
 376 VG_STATIC void player_mouseview(void);
 377
 378 #include "player_physics.h"
 379 #include "player_physics_skate.h"
 380 #include "player_physics_walk.h"
 381 #include "player_ragdoll.h"
 382 #include "player_model.h"
 383 #include "player_animation.h"
 384 #include "player_audio.h"
 385
 386 /*
 387  * player_physics_<INTERFACE>_<SUB-INTERFACE>
 388  *
 389  *
 390  *
 391  */
 392
 393 /*
 394  * -----------------------------------------------------------------------------
 395  *                                    Events
 396  * -----------------------------------------------------------------------------
 397  */
 398 VG_STATIC int kill_player( int argc, char const *argv[] );
 399 VG_STATIC int reset_player( int argc, char const *argv[] );
 400 VG_STATIC void reset_player_poll( int argc, char const *argv[] );
 401
 402 VG_STATIC void player_init(void)                                         /* 1 */
 403 {
 404    rb_init( &player.rb );
 405
 406    VG_VAR_F32( k_walkspeed );
 407    VG_VAR_F32( k_stopspeed );
 408    VG_VAR_F32( k_airspeed );
 409    VG_VAR_F32( k_walk_friction );
 410    VG_VAR_F32( k_walk_air_accel );
 411    VG_VAR_F32( k_walk_accel );
 412
 413    VG_VAR_I32( freecam );
 414    VG_VAR_I32( cl_thirdperson );
 415    VG_VAR_F32_PERSISTENT( fc_speed );
 416
 417    VG_VAR_F32( k_ragdoll_limit_scale );
 418    VG_VAR_I32( k_ragdoll_div );
 419    VG_VAR_I32( k_ragdoll_debug_collider );
 420    VG_VAR_I32( k_ragdoll_debug_constraints );
 421
 422    VG_VAR_F32( k_friction_lat );
 423
 424    VG_VAR_F32( k_cog_spring );
 425    VG_VAR_F32( k_cog_damp );
 426
 427    VG_VAR_F32( k_cog_mass_ratio );
 428    VG_VAR_F32( k_downforce );
 429
 430    VG_VAR_F32( k_spring_force );
 431    VG_VAR_F32( k_spring_dampener );
 432    VG_VAR_F32( k_spring_angular );
 433
 434    VG_VAR_F32( k_mmthrow_scale );
 435    VG_VAR_F32( k_mmcollect_lat );
 436    VG_VAR_F32( k_mmcollect_vert );
 437    VG_VAR_F32( k_mmdecay );
 438
 439         vg_function_push( (struct vg_cmd){
 440                 .name = "reset",
 441                 .function = reset_player,
 442       .poll_suggest = reset_player_poll
 443         });
 444
 445         vg_function_push( (struct vg_cmd){
 446                 .name = "kill",
 447                 .function = kill_player
 448         });
 449
 450    /* HACK */
 451    rb_register_cvar();
 452
 453    player.rewind_length = 0;
 454    player.rewind_buffer =
 455       vg_linear_alloc( vg_mem.rtmemory,
 456                        sizeof(struct rewind_frame) * PLAYER_REWIND_FRAMES );
 457
 458    player_model_init();
 459 }
 460
 461 VG_STATIC void player_save_rewind_frame(void)
 462 {
 463    if( player.rewind_length < PLAYER_REWIND_FRAMES )
 464    {
 465       struct rewind_frame *fr =
 466          &player.rewind_buffer[ player.rewind_length ++ ];
 467
 468       v2_copy( player.angles, fr->ang );
 469       v3_copy( player.camera_pos, fr->pos );
 470
 471       player.rewind_incrementer = 0;
 472
 473       if( player.rewind_length > 1 )
 474       {
 475          player.rewind_total_length +=
 476             v3_dist( player.rewind_buffer[player.rewind_length-1].pos,
 477                      player.rewind_buffer[player.rewind_length-2].pos );
 478       }
 479    }
 480 }
 481
 482
 483 /* disaster */
 484 VG_STATIC int         menu_enabled(void);
 485 #include "menu.h"
 486
 487 VG_STATIC void player_do_motion(void);
 488 /*
 489  * Free camera movement
 490  */
 491 VG_STATIC void player_mouseview(void)
 492 {
 493    if( menu_enabled() )
 494       return;
 495
 496    v2_muladds( player.angles, vg.mouse_delta, 0.0025f, player.angles );
 497
 498    if( vg_input.controller_should_use_trackpad_look )
 499    {
 500       static v2f last_input;
 501       static v2f vel;
 502       static v2f vel_smooth;
 503
 504       v2f input = { player.input_js2h->axis.value,
 505                     player.input_js2v->axis.value };
 506
 507       if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) )
 508       {
 509          v2_sub( input, last_input, vel );
 510          v2_muls( vel, 1.0f/vg.time_delta, vel );
 511       }
 512       else
 513       {
 514          v2_zero( vel );
 515       }
 516
 517       v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
 518
 519       v2_muladds( player.angles, vel_smooth, vg.time_delta, player.angles );
 520       v2_copy( input, last_input );
 521    }
 522    else
 523    {
 524       player.angles[0] += player.input_js2h->axis.value * vg.time_delta * 4.0f;
 525       player.angles[1] += player.input_js2v->axis.value * vg.time_delta * 4.0f;
 526    }
 527
 528    player.angles[1] = vg_clampf( player.angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
 529 }
 530
 531 /* Deal with input etc */
 532 VG_STATIC void player_update_pre(void)
 533 {
 534
 535    {
 536       v3f ra, rb, rx;
 537       v3_copy( main_camera.pos, ra );
 538       v3_muladds( ra, main_camera.transform[2], -10.0f, rb );
 539
 540       float t;
 541       if( spherecast_world( ra, rb, 0.4f, &t, rx ) != -1 )
 542       {
 543          m4x3f mtx;
 544          m3x3_identity( mtx );
 545          v3_lerp( ra, rb, t, mtx[3] );
 546
 547          debug_sphere( mtx, 0.4f, 0xff00ff00 );
 548
 549          v3f x1;
 550          v3_muladds( mtx[3], rx, 0.4f, x1 );
 551          vg_line( mtx[3], x1, 0xffffffff );
 552       }
 553    }
 554
 555 #if 0
 556
 557    vg_line_pt3( phys->cog, 0.10f, 0xffffffff );
 558    vg_line_pt3( phys->cog, 0.09f, 0xffffffff );
 559    vg_line_pt3( phys->cog, 0.08f, 0xffffffff );
 560    vg_line( phys->cog, phys->rb.co, 0xff000000 );
 561
 562    v3f spring_end;
 563    v3f throw_end, p0, p1;
 564    v3_muladds( phys->rb.co, phys->rb.up, 1.0f, spring_end );
 565    v3_muladds( spring_end, phys->throw_v, 1.0f, throw_end );
 566    v3_muladds( spring_end, player.debug_mmcollect_lat, 1.0f, p0 );
 567    v3_muladds( spring_end, player.debug_mmcollect_vert, 1.0f, p1 );
 568    vg_line( spring_end, throw_end, VG__RED );
 569    vg_line( spring_end, p0, VG__GREEN );
 570    vg_line( spring_end, p1, VG__BLUE );
 571 #endif
 572
 573    if( player.rewinding )
 574       return;
 575
 576    if( vg_input_button_down( player.input_reset ) && !menu_enabled() )
 577    {
 578       double delta = world.time - world.last_use;
 579
 580       if( (delta <= RESET_MAX_TIME) && (world.last_use != 0.0) )
 581       {
 582          player.rewinding = 1;
 583          player.rewind_sound_wait = 1;
 584          player.rewind_time = (float)player.rewind_length - 0.0001f;
 585          player_save_rewind_frame();
 586          audio_lock();
 587          audio_play_oneshot( &audio_rewind[0], 1.0f );
 588          audio_unlock();
 589
 590          /* based on analytical testing. DONT CHANGE!
 591           *
 592           *    time taken: y = (x^(4/5)) * 74.5
 593           *    inverse   : x = (2/149)^(4/5) * y^(4/5)
 594           */
 595
 596          float constant = powf( 2.0f/149.0f, 4.0f/5.0f ),
 597                curve    = powf( player.rewind_total_length, 4.0f/5.0f );
 598
 599          player.rewind_predicted_time = constant * curve;
 600          player.diag_rewind_start = vg.time;
 601          player.diag_rewind_time  = player.rewind_time;
 602
 603          player.is_dead = 0;
 604          player.death_tick_allowance = 30;
 605          player_restore_frame();
 606
 607          if( player.controller == k_player_controller_walk )
 608          {
 609             player.angles[0] = atan2f( -player.rb.forward[2],
 610                                        -player.rb.forward[0] );
 611          }
 612
 613          player.mdl.shoes[0] = 1;
 614          player.mdl.shoes[1] = 1;
 615
 616          world_routes_notify_reset();
 617
 618          /* apply 1 frame of movement */
 619          player_do_motion();
 620       }
 621       else
 622       {
 623          if( player.is_dead )
 624          {
 625             reset_player( 0, NULL );
 626          }
 627          else
 628          {
 629             /* cant do that */
 630             audio_lock();
 631             audio_play_oneshot( &audio_rewind[4], 1.0f );
 632             audio_unlock();
 633          }
 634       }
 635    }
 636
 637    if( vg_input_button_down( player.input_switch_mode ) && !menu_enabled() )
 638    {
 639       audio_lock();
 640
 641 #if 0
 642       if( phys->controller == k_player_controller_walk )
 643       {
 644          phys->controller = k_player_controller_skate;
 645
 646          v3_muladds( phys->rb.v, phys->rb.forward, 0.2f, phys->rb.v );
 647          audio_play_oneshot( &audio_lands[6], 1.0f );
 648       }
 649       else if( phys->controller == k_player_controller_skate )
 650       {
 651          phys->controller = k_player_controller_walk;
 652
 653          audio_play_oneshot( &audio_lands[5], 1.0f );
 654       }
 655 #endif
 656
 657       audio_unlock();
 658    }
 659
 660    if( player.controller == k_player_controller_walk )
 661       player_mouseview();
 662 }
 663
 664 VG_STATIC void player_update_fixed(void)                                 /* 2 */
 665 {
 666    if( player.rewinding )
 667       return;
 668
 669    if( player.death_tick_allowance )
 670       player.death_tick_allowance --;
 671
 672    if( player.is_dead )
 673    {
 674       player_ragdoll_iter();
 675    }
 676    else
 677    {
 678       player.rewind_incrementer ++;
 679
 680       if( player.rewind_incrementer > (u32)(0.25/VG_TIMESTEP_FIXED) )
 681       {
 682          player_save_rewind_frame();
 683       }
 684
 685       player_do_motion();
 686    }
 687 }
 688
 689 VG_STATIC void player_update_post(void)
 690 {
 691 #if 0
 692    for( int i=0; i<player.prediction_count; i++ )
 693    {
 694       struct land_prediction *p = &player.predictions[i];
 695
 696       for( int j=0; j<p->log_length - 1; j ++ )
 697          vg_line( p->log[j], p->log[j+1], p->colour );
 698
 699       vg_line_cross( p->log[p->log_length-1], p->colour, 0.25f );
 700
 701       v3f p1;
 702       v3_add( p->log[p->log_length-1], p->n, p1 );
 703       vg_line( p->log[p->log_length-1], p1, 0xffffffff );
 704    }
 705 #endif
 706
 707 #if 0
 708    if( player.is_dead )
 709    {
 710       player_debug_ragdoll();
 711
 712       if( !freecam )
 713          player_animate_death_cam();
 714    }
 715    else
 716    {
 717       player_animate();
 718
 719       if( !freecam )
 720       {
 721          if( cl_thirdperson )
 722             player_animate_camera_thirdperson();
 723          else
 724             player_animate_camera();
 725       }
 726    }
 727
 728    if( freecam )
 729 #endif
 730       player_freecam();
 731
 732    /* CAMERA POSITIONING: LAYER 0 */
 733    v2_copy( player.angles, main_camera.angles );
 734    v3_copy( player.camera_pos, main_camera.pos );
 735
 736 #if 0
 737    if( player.rewinding )
 738    {
 739       if( player.rewind_time <= 0.0f )
 740       {
 741          double taken = vg.time - player.diag_rewind_start;
 742          vg_success( "Rewind took (rt, pl, tl): %f, %f, %f\n",
 743                            taken, player.diag_rewind_time,
 744                            player.rewind_total_length );
 745
 746          player.rewinding = 0;
 747          player.rewind_length = 1;
 748          player.rewind_total_length = 0.0f;
 749          player.rewind_incrementer = 0;
 750          world.sky_target_rate = 1.0;
 751       }
 752       else
 753       {
 754          world.sky_target_rate = -100.0;
 755          assert( player.rewind_length > 0 );
 756
 757          v2f override_angles;
 758          v3f override_pos;
 759
 760          float budget         = vg.time_delta,
 761                overall_length = player.rewind_length;
 762
 763          world_routes_rollback_time( player.rewind_time / overall_length );
 764
 765          for( int i=0; (i<10)&&(player.rewind_time>0.0f)&&(budget>0.0f); i ++ )
 766          {
 767             /* Interpolate frames */
 768             int i0 = floorf( player.rewind_time ),
 769                 i1 = VG_MIN( i0+1, player.rewind_length-1 );
 770
 771             struct rewind_frame *fr =  &player.rewind_buffer[i0],
 772                                 *fr1 = &player.rewind_buffer[i1];
 773
 774             float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
 775                   subl = vg_fractf( player.rewind_time ) + 0.001f,
 776
 777                   sramp= 3.0f-(1.0f/(0.4f+0.4f*player.rewind_time)),
 778                   speed = sramp*28.0f + 0.5f*player.rewind_time,
 779                   mod  = speed * (budget / dist),
 780
 781                   advl = vg_minf( mod, subl ),
 782                   advt = (advl / mod) * budget;
 783
 784             player.dist_accum += speed * advt;
 785             player.rewind_time -= advl;
 786             budget -= advt;
 787          }
 788
 789          player.rewind_time = vg_maxf( 0.0f, player.rewind_time );
 790
 791          float current_time = vg.time - player.diag_rewind_start,
 792                remaining    = player.rewind_predicted_time - current_time;
 793
 794          if( player.rewind_sound_wait )
 795          {
 796             if( player.rewind_predicted_time >= 6.5f )
 797             {
 798                if( remaining <= 6.5f )
 799                {
 800                   audio_lock();
 801                   audio_play_oneshot( &audio_rewind[3], 1.0f );
 802                   audio_unlock();
 803                   player.rewind_sound_wait = 0;
 804                }
 805             }
 806             else if( player.rewind_predicted_time >= 2.5f )
 807             {
 808                if( remaining <= 2.5f )
 809                {
 810                   audio_lock();
 811                   audio_play_oneshot( &audio_rewind[2], 1.0f );
 812                   audio_unlock();
 813                   player.rewind_sound_wait = 0;
 814                }
 815             }
 816             else if( player.rewind_predicted_time >= 1.5f )
 817             {
 818                if( remaining <= 1.5f )
 819                {
 820                   audio_lock();
 821                   audio_play_oneshot( &audio_rewind[1], 1.0f );
 822                   audio_unlock();
 823                   player.rewind_sound_wait = 0;
 824                }
 825             }
 826          }
 827
 828          int i0 = floorf( player.rewind_time ),
 829              i1 = VG_MIN( i0+1, player.rewind_length-1 );
 830
 831          struct rewind_frame *fr =  &player.rewind_buffer[i0],
 832                              *fr1 = &player.rewind_buffer[i1];
 833
 834          float sub = vg_fractf(player.rewind_time);
 835
 836          v3_lerp( fr->pos, fr1->pos, sub, override_pos );
 837          override_angles[0] = vg_alerpf( fr->ang[0], fr1->ang[0], sub );
 838          override_angles[1] = vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
 839
 840          /* CAMERA POSITIONING: LAYER 1 */
 841          float blend = (4.0f-player.rewind_time) * 0.25f,
 842                c     = vg_clampf( blend, 0.0f, 1.0f );
 843
 844          main_camera.angles[0] =
 845             vg_alerpf(override_angles[0], player.angles[0], c);
 846          main_camera.angles[1] =
 847             vg_lerpf (override_angles[1], player.angles[1], c);
 848          v3_lerp( override_pos, player.camera_pos, c, main_camera.pos );
 849       }
 850    }
 851 #endif
 852
 853    camera_update_transform( &main_camera );
 854    player_audio();
 855 }
 856
 857 VG_STATIC void draw_player( camera *cam )
 858 {
 859    if( player.is_dead )
 860       player_model_copy_ragdoll();
 861
 862    shader_viewchar_use();
 863    vg_tex2d_bind( &tex_characters, 0 );
 864    shader_viewchar_uTexMain( 0 );
 865    shader_viewchar_uCamera( cam->transform[3] );
 866    shader_viewchar_uPv( cam->mtx.pv );
 867    shader_link_standard_ub( _shader_viewchar.id, 2 );
 868    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
 869                          player.mdl.sk.bone_count,
 870                          0,
 871                          (float *)player.mdl.sk.final_mtx );
 872
 873    mesh_bind( &player.mdl.player_meshes[cl_playermdl_id] );
 874    mesh_draw( &player.mdl.player_meshes[cl_playermdl_id] );
 875 }
 876
 877 VG_STATIC void player_do_motion(void)
 878 {
 879    if( world.water.enabled )
 880    {
 881       if( (player.rb.co[1] < 0.0f) && !player.is_dead )
 882       {
 883          audio_lock();
 884          audio_player_set_flags( &audio_player_extra, AUDIO_FLAG_SPACIAL_3D );
 885          audio_player_set_position( &audio_player_extra, player.rb.co );
 886          audio_player_set_vol( &audio_player_extra, 20.0f );
 887          audio_player_playclip( &audio_player_extra, &audio_splash );
 888          audio_unlock();
 889
 890          player_kill();
 891       }
 892    }
 893
 894    v3f prevco;
 895    v3_copy( player.rb.co, prevco );
 896
 897    if( player.controller == k_player_controller_skate )
 898    {
 899 #if 0
 900       player_skate_update();
 901 #endif
 902    }
 903    else
 904       player_walk_physics( &player_walky );
 905
 906
 907    /* Real angular velocity integration */
 908 #if 0
 909    v3_lerp( phys->rb.w, (v3f){0.0f,0.0f,0.0f}, 0.125f*0.5f, phys->rb.w );
 910    if( v3_length2( phys->rb.w ) > 0.0f )
 911    {
 912       v4f rotation;
 913       v3f axis;
 914       v3_copy( phys->rb.w, axis );
 915
 916       float mag = v3_length( axis );
 917       v3_divs( axis, mag, axis );
 918       q_axis_angle( rotation, axis, mag*k_rb_delta );
 919       q_mul( rotation, phys->rb.q, phys->rb.q );
 920    }
 921
 922    /* Faux angular velocity */
 923    v4f rotate;
 924
 925    float lerpq = (player_skate.activity == k_skate_activity_air)? 0.04f: 0.3f;
 926    phys->siY = vg_lerpf( phys->siY, phys->iY, lerpq );
 927
 928    q_axis_angle( rotate, phys->rb.up, phys->siY );
 929    q_mul( rotate, phys->rb.q, phys->rb.q );
 930    phys->iY = 0.0f;
 931 #endif
 932
 933    /*
 934     * Gate intersection, by tracing a line over the gate planes
 935     */
 936 #if 0
 937    for( int i=0; i<world.gate_count; i++ )
 938    {
 939       struct route_gate *rg = &world.gates[i];
 940       teleport_gate *gate = &rg->gate;
 941
 942       if( gate_intersect( gate, phys->rb.co, prevco ) )
 943       {
 944          m4x3_mulv( gate->transport, phys->rb.co, phys->rb.co );
 945          m4x3_mulv( gate->transport, phys->cog, phys->cog );
 946          m3x3_mulv( gate->transport, phys->cog_v, phys->cog_v );
 947          m3x3_mulv( gate->transport, phys->rb.v, phys->rb.v );
 948          m3x3_mulv( gate->transport, phys->vl, phys->vl );
 949          m3x3_mulv( gate->transport, phys->v_last, phys->v_last );
 950          m3x3_mulv( gate->transport, phys->m, phys->m );
 951          m3x3_mulv( gate->transport, phys->bob, phys->bob );
 952
 953          /* Pre-emptively edit the camera matrices so that the motion vectors
 954           * are correct */
 955          m4x3f transport_i;
 956          m4x4f transport_4;
 957          m4x3_invert_affine( gate->transport, transport_i );
 958          m4x3_expand( transport_i, transport_4 );
 959          m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
 960          m4x4_mul( main_camera.mtx.v, transport_4, main_camera.mtx.v );
 961
 962          v4f transport_rotation;
 963          m3x3_q( gate->transport, transport_rotation );
 964          q_mul( transport_rotation, phys->rb.q, phys->rb.q );
 965
 966          world_routes_activate_gate( i );
 967
 968          if( phys->controller == k_player_controller_walk )
 969          {
 970             v3f fwd_dir = {cosf(player.angles[0]),
 971                            0.0f,
 972                            sinf(player.angles[0])};
 973             m3x3_mulv( gate->transport, fwd_dir, fwd_dir );
 974
 975             player.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
 976          }
 977
 978          player.rewind_length = 0;
 979          player.rewind_total_length = 0.0f;
 980          player.rewind_incrementer = 10000;
 981          player_save_frame();
 982
 983          audio_lock();
 984          audio_play_oneshot( &audio_gate_pass, 1.0f );
 985          audio_unlock();
 986          break;
 987       }
 988    }
 989 #endif
 990
 991    rb_update_transform( &player.rb );
 992 }
 993
 994 /*
 995  * -----------------------------------------------------------------------------
 996  *                              API implementation
 997  * -----------------------------------------------------------------------------
 998  */
 999
1000 VG_STATIC float *player_get_pos(void)
1001 {
1002    return player.rb.co;
1003 }
1004
1005 VG_STATIC void player_kill(void)
1006 {
1007    if( player.death_tick_allowance == 0 )
1008    {
1009       player.is_dead = 1;
1010       player_ragdoll_copy_model( player.rb.v );
1011    }
1012 }
1013
1014 VG_STATIC float *player_cam_pos(void)
1015 {
1016    return player.camera_pos;
1017 }
1018
1019
1020 VG_STATIC void player_save_frame(void)
1021 {
1022    player.controller_frame = player.controller;
1023
1024    /* TODO         <interface>->save() */
1025 }
1026
1027 VG_STATIC void player_restore_frame(void)
1028 {
1029    player.controller = player.controller_frame;
1030
1031    /* TODO         <interface>->load() */
1032 }
1033
1034 #endif /* PLAYER_H */
1035 #endif