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    NULL,
 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    /* TODO: NOT PERSISTENT */
 418    VG_VAR_F32( k_ragdoll_limit_scale );
 419    VG_VAR_I32( k_ragdoll_div );
 420    VG_VAR_I32( k_ragdoll_debug_collider );
 421    VG_VAR_I32( k_ragdoll_debug_constraints );
 422
 423    VG_VAR_F32( k_friction_lat );
 424
 425    VG_VAR_F32( k_cog_spring );
 426    VG_VAR_F32( k_cog_damp );
 427
 428    VG_VAR_F32( k_cog_mass_ratio );
 429    VG_VAR_F32( k_downforce );
 430
 431    VG_VAR_F32( k_spring_force );
 432    VG_VAR_F32( k_spring_dampener );
 433    VG_VAR_F32( k_spring_angular );
 434
 435    VG_VAR_F32( k_mmthrow_scale );
 436    VG_VAR_F32( k_mmcollect_lat );
 437    VG_VAR_F32( k_mmcollect_vert );
 438    VG_VAR_F32( k_mmdecay );
 439
 440         vg_function_push( (struct vg_cmd){
 441                 .name = "reset",
 442                 .function = reset_player,
 443       .poll_suggest = reset_player_poll
 444         });
 445
 446         vg_function_push( (struct vg_cmd){
 447                 .name = "kill",
 448                 .function = kill_player
 449         });
 450
 451    /* HACK */
 452    rb_register_cvar();
 453
 454    player.rewind_length = 0;
 455    player.rewind_buffer =
 456       vg_linear_alloc( vg_mem.rtmemory,
 457                        sizeof(struct rewind_frame) * PLAYER_REWIND_FRAMES );
 458
 459    player_model_init();
 460 }
 461
 462 VG_STATIC void player_save_rewind_frame(void)
 463 {
 464    if( player.rewind_length < PLAYER_REWIND_FRAMES )
 465    {
 466       struct rewind_frame *fr =
 467          &player.rewind_buffer[ player.rewind_length ++ ];
 468
 469       v2_copy( player.angles, fr->ang );
 470       v3_copy( player.camera_pos, fr->pos );
 471
 472       player.rewind_incrementer = 0;
 473
 474       if( player.rewind_length > 1 )
 475       {
 476          player.rewind_total_length +=
 477             v3_dist( player.rewind_buffer[player.rewind_length-1].pos,
 478                      player.rewind_buffer[player.rewind_length-2].pos );
 479       }
 480    }
 481 }
 482
 483
 484 /* disaster */
 485 VG_STATIC int         menu_enabled(void);
 486 #include "menu.h"
 487
 488 VG_STATIC void player_do_motion(void);
 489 /*
 490  * Free camera movement
 491  */
 492 VG_STATIC void player_mouseview(void)
 493 {
 494    if( menu_enabled() )
 495       return;
 496
 497    v2_muladds( player.angles, vg.mouse_delta, 0.0025f, player.angles );
 498
 499    if( vg_input.controller_should_use_trackpad_look )
 500    {
 501       static v2f last_input;
 502       static v2f vel;
 503       static v2f vel_smooth;
 504
 505       v2f input = { player.input_js2h->axis.value,
 506                     player.input_js2v->axis.value };
 507
 508       if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) )
 509       {
 510          v2_sub( input, last_input, vel );
 511          v2_muls( vel, 1.0f/vg.time_delta, vel );
 512       }
 513       else
 514       {
 515          v2_zero( vel );
 516       }
 517
 518       v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
 519
 520       v2_muladds( player.angles, vel_smooth, vg.time_delta, player.angles );
 521       v2_copy( input, last_input );
 522    }
 523    else
 524    {
 525       player.angles[0] += player.input_js2h->axis.value * vg.time_delta * 4.0f;
 526       player.angles[1] += player.input_js2v->axis.value * vg.time_delta * 4.0f;
 527    }
 528
 529    player.angles[1] = vg_clampf( player.angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
 530 }
 531
 532 /* Deal with input etc */
 533 VG_STATIC void player_update_pre(void)
 534 {
 535
 536    {
 537       v3f ra, rb, rx;
 538       v3_copy( main_camera.pos, ra );
 539       v3_muladds( ra, main_camera.transform[2], -10.0f, rb );
 540
 541       float t;
 542       if( spherecast_world( ra, rb, 0.4f, &t, rx ) != -1 )
 543       {
 544          m4x3f mtx;
 545          m3x3_identity( mtx );
 546          v3_lerp( ra, rb, t, mtx[3] );
 547
 548          debug_sphere( mtx, 0.4f, 0xff00ff00 );
 549
 550          v3f x1;
 551          v3_muladds( mtx[3], rx, 0.4f, x1 );
 552          vg_line( mtx[3], x1, 0xffffffff );
 553       }
 554    }
 555
 556 #if 0
 557
 558    vg_line_pt3( phys->cog, 0.10f, 0xffffffff );
 559    vg_line_pt3( phys->cog, 0.09f, 0xffffffff );
 560    vg_line_pt3( phys->cog, 0.08f, 0xffffffff );
 561    vg_line( phys->cog, phys->rb.co, 0xff000000 );
 562
 563    v3f spring_end;
 564    v3f throw_end, p0, p1;
 565    v3_muladds( phys->rb.co, phys->rb.up, 1.0f, spring_end );
 566    v3_muladds( spring_end, phys->throw_v, 1.0f, throw_end );
 567    v3_muladds( spring_end, player.debug_mmcollect_lat, 1.0f, p0 );
 568    v3_muladds( spring_end, player.debug_mmcollect_vert, 1.0f, p1 );
 569    vg_line( spring_end, throw_end, VG__RED );
 570    vg_line( spring_end, p0, VG__GREEN );
 571    vg_line( spring_end, p1, VG__BLUE );
 572 #endif
 573
 574    if( player.rewinding )
 575       return;
 576
 577    if( vg_input_button_down( player.input_reset ) && !menu_enabled() )
 578    {
 579       double delta = world.time - world.last_use;
 580
 581       if( (delta <= RESET_MAX_TIME) && (world.last_use != 0.0) )
 582       {
 583          player.rewinding = 1;
 584          player.rewind_sound_wait = 1;
 585          player.rewind_time = (float)player.rewind_length - 0.0001f;
 586          player_save_rewind_frame();
 587          audio_lock();
 588          audio_play_oneshot( &audio_rewind[0], 1.0f );
 589          audio_unlock();
 590
 591          /* based on analytical testing. DONT CHANGE!
 592           *
 593           *    time taken: y = (x^(4/5)) * 74.5
 594           *    inverse   : x = (2/149)^(4/5) * y^(4/5)
 595           */
 596
 597          float constant = powf( 2.0f/149.0f, 4.0f/5.0f ),
 598                curve    = powf( player.rewind_total_length, 4.0f/5.0f );
 599
 600          player.rewind_predicted_time = constant * curve;
 601          player.diag_rewind_start = vg.time;
 602          player.diag_rewind_time  = player.rewind_time;
 603
 604          player.is_dead = 0;
 605          player.death_tick_allowance = 30;
 606          player_restore_frame();
 607
 608          if( player.controller == k_player_controller_walk )
 609          {
 610             player.angles[0] = atan2f( -player.rb.forward[2],
 611                                        -player.rb.forward[0] );
 612          }
 613
 614          player.mdl.shoes[0] = 1;
 615          player.mdl.shoes[1] = 1;
 616
 617          world_routes_notify_reset();
 618
 619          /* apply 1 frame of movement */
 620          player_do_motion();
 621       }
 622       else
 623       {
 624          if( player.is_dead )
 625          {
 626             reset_player( 0, NULL );
 627          }
 628          else
 629          {
 630             /* cant do that */
 631             audio_lock();
 632             audio_play_oneshot( &audio_rewind[4], 1.0f );
 633             audio_unlock();
 634          }
 635       }
 636    }
 637
 638    if( vg_input_button_down( player.input_switch_mode ) && !menu_enabled() )
 639    {
 640       audio_lock();
 641
 642 #if 0
 643       if( phys->controller == k_player_controller_walk )
 644       {
 645          phys->controller = k_player_controller_skate;
 646
 647          v3_muladds( phys->rb.v, phys->rb.forward, 0.2f, phys->rb.v );
 648          audio_play_oneshot( &audio_lands[6], 1.0f );
 649       }
 650       else if( phys->controller == k_player_controller_skate )
 651       {
 652          phys->controller = k_player_controller_walk;
 653
 654          audio_play_oneshot( &audio_lands[5], 1.0f );
 655       }
 656 #endif
 657
 658       audio_unlock();
 659    }
 660
 661    if( player.controller == k_player_controller_walk )
 662       player_mouseview();
 663 }
 664
 665 VG_STATIC void player_update_fixed(void)                                 /* 2 */
 666 {
 667    if( player.rewinding )
 668       return;
 669
 670    if( player.death_tick_allowance )
 671       player.death_tick_allowance --;
 672
 673    if( player.is_dead )
 674    {
 675       player_ragdoll_iter();
 676    }
 677    else
 678    {
 679       player.rewind_incrementer ++;
 680
 681       if( player.rewind_incrementer > (u32)(0.25/VG_TIMESTEP_FIXED) )
 682       {
 683          player_save_rewind_frame();
 684       }
 685
 686       player_do_motion();
 687    }
 688 }
 689
 690 VG_STATIC void player_update_post(void)
 691 {
 692 #if 0
 693    for( int i=0; i<player.prediction_count; i++ )
 694    {
 695       struct land_prediction *p = &player.predictions[i];
 696
 697       for( int j=0; j<p->log_length - 1; j ++ )
 698          vg_line( p->log[j], p->log[j+1], p->colour );
 699
 700       vg_line_cross( p->log[p->log_length-1], p->colour, 0.25f );
 701
 702       v3f p1;
 703       v3_add( p->log[p->log_length-1], p->n, p1 );
 704       vg_line( p->log[p->log_length-1], p1, 0xffffffff );
 705    }
 706 #endif
 707
 708 #if 0
 709    if( player.is_dead )
 710    {
 711       player_debug_ragdoll();
 712
 713       if( !freecam )
 714          player_animate_death_cam();
 715    }
 716    else
 717    {
 718       player_animate();
 719
 720       if( !freecam )
 721       {
 722          if( cl_thirdperson )
 723             player_animate_camera_thirdperson();
 724          else
 725             player_animate_camera();
 726       }
 727    }
 728
 729    if( freecam )
 730 #endif
 731       player_freecam();
 732
 733    /* CAMERA POSITIONING: LAYER 0 */
 734    v2_copy( player.angles, main_camera.angles );
 735    v3_copy( player.camera_pos, main_camera.pos );
 736
 737 #if 0
 738    if( player.rewinding )
 739    {
 740       if( player.rewind_time <= 0.0f )
 741       {
 742          double taken = vg.time - player.diag_rewind_start;
 743          vg_success( "Rewind took (rt, pl, tl): %f, %f, %f\n",
 744                            taken, player.diag_rewind_time,
 745                            player.rewind_total_length );
 746
 747          player.rewinding = 0;
 748          player.rewind_length = 1;
 749          player.rewind_total_length = 0.0f;
 750          player.rewind_incrementer = 0;
 751          world.sky_target_rate = 1.0;
 752       }
 753       else
 754       {
 755          world.sky_target_rate = -100.0;
 756          assert( player.rewind_length > 0 );
 757
 758          v2f override_angles;
 759          v3f override_pos;
 760
 761          float budget         = vg.time_delta,
 762                overall_length = player.rewind_length;
 763
 764          world_routes_rollback_time( player.rewind_time / overall_length );
 765
 766          for( int i=0; (i<10)&&(player.rewind_time>0.0f)&&(budget>0.0f); i ++ )
 767          {
 768             /* Interpolate frames */
 769             int i0 = floorf( player.rewind_time ),
 770                 i1 = VG_MIN( i0+1, player.rewind_length-1 );
 771
 772             struct rewind_frame *fr =  &player.rewind_buffer[i0],
 773                                 *fr1 = &player.rewind_buffer[i1];
 774
 775             float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
 776                   subl = vg_fractf( player.rewind_time ) + 0.001f,
 777
 778                   sramp= 3.0f-(1.0f/(0.4f+0.4f*player.rewind_time)),
 779                   speed = sramp*28.0f + 0.5f*player.rewind_time,
 780                   mod  = speed * (budget / dist),
 781
 782                   advl = vg_minf( mod, subl ),
 783                   advt = (advl / mod) * budget;
 784
 785             player.dist_accum += speed * advt;
 786             player.rewind_time -= advl;
 787             budget -= advt;
 788          }
 789
 790          player.rewind_time = vg_maxf( 0.0f, player.rewind_time );
 791
 792          float current_time = vg.time - player.diag_rewind_start,
 793                remaining    = player.rewind_predicted_time - current_time;
 794
 795          if( player.rewind_sound_wait )
 796          {
 797             if( player.rewind_predicted_time >= 6.5f )
 798             {
 799                if( remaining <= 6.5f )
 800                {
 801                   audio_lock();
 802                   audio_play_oneshot( &audio_rewind[3], 1.0f );
 803                   audio_unlock();
 804                   player.rewind_sound_wait = 0;
 805                }
 806             }
 807             else if( player.rewind_predicted_time >= 2.5f )
 808             {
 809                if( remaining <= 2.5f )
 810                {
 811                   audio_lock();
 812                   audio_play_oneshot( &audio_rewind[2], 1.0f );
 813                   audio_unlock();
 814                   player.rewind_sound_wait = 0;
 815                }
 816             }
 817             else if( player.rewind_predicted_time >= 1.5f )
 818             {
 819                if( remaining <= 1.5f )
 820                {
 821                   audio_lock();
 822                   audio_play_oneshot( &audio_rewind[1], 1.0f );
 823                   audio_unlock();
 824                   player.rewind_sound_wait = 0;
 825                }
 826             }
 827          }
 828
 829          int i0 = floorf( player.rewind_time ),
 830              i1 = VG_MIN( i0+1, player.rewind_length-1 );
 831
 832          struct rewind_frame *fr =  &player.rewind_buffer[i0],
 833                              *fr1 = &player.rewind_buffer[i1];
 834
 835          float sub = vg_fractf(player.rewind_time);
 836
 837          v3_lerp( fr->pos, fr1->pos, sub, override_pos );
 838          override_angles[0] = vg_alerpf( fr->ang[0], fr1->ang[0], sub );
 839          override_angles[1] = vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
 840
 841          /* CAMERA POSITIONING: LAYER 1 */
 842          float blend = (4.0f-player.rewind_time) * 0.25f,
 843                c     = vg_clampf( blend, 0.0f, 1.0f );
 844
 845          main_camera.angles[0] =
 846             vg_alerpf(override_angles[0], player.angles[0], c);
 847          main_camera.angles[1] =
 848             vg_lerpf (override_angles[1], player.angles[1], c);
 849          v3_lerp( override_pos, player.camera_pos, c, main_camera.pos );
 850       }
 851    }
 852 #endif
 853
 854    camera_update_transform( &main_camera );
 855    player_audio();
 856 }
 857
 858 VG_STATIC void draw_player( camera *cam )
 859 {
 860    if( player.is_dead )
 861       player_model_copy_ragdoll();
 862
 863    shader_viewchar_use();
 864    vg_tex2d_bind( &tex_characters, 0 );
 865    shader_viewchar_uTexMain( 0 );
 866    shader_viewchar_uCamera( cam->transform[3] );
 867    shader_viewchar_uPv( cam->mtx.pv );
 868    shader_link_standard_ub( _shader_viewchar.id, 2 );
 869    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
 870                          player.mdl.sk.bone_count,
 871                          0,
 872                          (float *)player.mdl.sk.final_mtx );
 873
 874    mesh_bind( &player.mdl.player_meshes[cl_playermdl_id] );
 875    mesh_draw( &player.mdl.player_meshes[cl_playermdl_id] );
 876 }
 877
 878 VG_STATIC void player_do_motion(void)
 879 {
 880    if( world.water.enabled )
 881    {
 882       if( (player.rb.co[1] < 0.0f) && !player.is_dead )
 883       {
 884          audio_lock();
 885          audio_player_set_flags( &audio_player_extra, AUDIO_FLAG_SPACIAL_3D );
 886          audio_player_set_position( &audio_player_extra, player.rb.co );
 887          audio_player_set_vol( &audio_player_extra, 20.0f );
 888          audio_player_playclip( &audio_player_extra, &audio_splash );
 889          audio_unlock();
 890
 891          player_kill();
 892       }
 893    }
 894
 895    v3f prevco;
 896    v3_copy( player.rb.co, prevco );
 897
 898    if( player.controller == k_player_controller_skate )
 899    {
 900 #if 0
 901       player_skate_update();
 902 #endif
 903    }
 904    else
 905       player_walk_physics( &player_walky );
 906
 907
 908    /* Real angular velocity integration */
 909 #if 0
 910    v3_lerp( phys->rb.w, (v3f){0.0f,0.0f,0.0f}, 0.125f*0.5f, phys->rb.w );
 911    if( v3_length2( phys->rb.w ) > 0.0f )
 912    {
 913       v4f rotation;
 914       v3f axis;
 915       v3_copy( phys->rb.w, axis );
 916
 917       float mag = v3_length( axis );
 918       v3_divs( axis, mag, axis );
 919       q_axis_angle( rotation, axis, mag*k_rb_delta );
 920       q_mul( rotation, phys->rb.q, phys->rb.q );
 921    }
 922
 923    /* Faux angular velocity */
 924    v4f rotate;
 925
 926    float lerpq = (player_skate.activity == k_skate_activity_air)? 0.04f: 0.3f;
 927    phys->siY = vg_lerpf( phys->siY, phys->iY, lerpq );
 928
 929    q_axis_angle( rotate, phys->rb.up, phys->siY );
 930    q_mul( rotate, phys->rb.q, phys->rb.q );
 931    phys->iY = 0.0f;
 932 #endif
 933
 934    /*
 935     * Gate intersection, by tracing a line over the gate planes
 936     */
 937 #if 0
 938    for( int i=0; i<world.gate_count; i++ )
 939    {
 940       struct route_gate *rg = &world.gates[i];
 941       teleport_gate *gate = &rg->gate;
 942
 943       if( gate_intersect( gate, phys->rb.co, prevco ) )
 944       {
 945          m4x3_mulv( gate->transport, phys->rb.co, phys->rb.co );
 946          m4x3_mulv( gate->transport, phys->cog, phys->cog );
 947          m3x3_mulv( gate->transport, phys->cog_v, phys->cog_v );
 948          m3x3_mulv( gate->transport, phys->rb.v, phys->rb.v );
 949          m3x3_mulv( gate->transport, phys->vl, phys->vl );
 950          m3x3_mulv( gate->transport, phys->v_last, phys->v_last );
 951          m3x3_mulv( gate->transport, phys->m, phys->m );
 952          m3x3_mulv( gate->transport, phys->bob, phys->bob );
 953
 954          /* Pre-emptively edit the camera matrices so that the motion vectors
 955           * are correct */
 956          m4x3f transport_i;
 957          m4x4f transport_4;
 958          m4x3_invert_affine( gate->transport, transport_i );
 959          m4x3_expand( transport_i, transport_4 );
 960          m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
 961          m4x4_mul( main_camera.mtx.v, transport_4, main_camera.mtx.v );
 962
 963          v4f transport_rotation;
 964          m3x3_q( gate->transport, transport_rotation );
 965          q_mul( transport_rotation, phys->rb.q, phys->rb.q );
 966
 967          world_routes_activate_gate( i );
 968
 969          if( phys->controller == k_player_controller_walk )
 970          {
 971             v3f fwd_dir = {cosf(player.angles[0]),
 972                            0.0f,
 973                            sinf(player.angles[0])};
 974             m3x3_mulv( gate->transport, fwd_dir, fwd_dir );
 975
 976             player.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
 977          }
 978
 979          player.rewind_length = 0;
 980          player.rewind_total_length = 0.0f;
 981          player.rewind_incrementer = 10000;
 982          player_save_frame();
 983
 984          audio_lock();
 985          audio_play_oneshot( &audio_gate_pass, 1.0f );
 986          audio_unlock();
 987          break;
 988       }
 989    }
 990 #endif
 991
 992    rb_update_transform( &player.rb );
 993 }
 994
 995 /*
 996  * -----------------------------------------------------------------------------
 997  *                              API implementation
 998  * -----------------------------------------------------------------------------
 999  */
1000
1001 VG_STATIC float *player_get_pos(void)
1002 {
1003    return player.rb.co;
1004 }
1005
1006 VG_STATIC void player_kill(void)
1007 {
1008    if( player.death_tick_allowance == 0 )
1009    {
1010       player.is_dead = 1;
1011       player_ragdoll_copy_model( player.rb.v );
1012    }
1013 }
1014
1015 VG_STATIC float *player_cam_pos(void)
1016 {
1017    return player.camera_pos;
1018 }
1019
1020
1021 VG_STATIC void player_save_frame(void)
1022 {
1023    player.controller_frame = player.controller;
1024
1025    /* TODO         <interface>->save() */
1026 }
1027
1028 VG_STATIC void player_restore_frame(void)
1029 {
1030    player.controller = player.controller_frame;
1031
1032    /* TODO         <interface>->load() */
1033 }
1034
1035 #endif /* PLAYER_H */
1036 #endif