player_animation.h

   1 /*
   2  * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
   3  */
   4
   5 #ifndef PLAYER_ANIMATION_H
   6 #define PLAYER_ANIMATION_H
   7
   8 #include "player.h"
   9
  10 VG_STATIC void player_animate_offboard(void)
  11 {
  12    {
  13       float fly = player.phys.in_air,
  14             rate;
  15
  16       if( player.phys.in_air )
  17          rate = 2.4f;
  18       else
  19          rate = 9.0f;
  20
  21       player.ffly  = vg_lerpf( player.ffly, fly, rate*vg.time_delta );
  22       player.frun  = vg_lerpf( player.frun,
  23                                player.walk *
  24                                (1.0f + player.input_walk->button.value*0.5f),
  25                                2.0f*vg.time_delta );
  26    }
  27
  28    struct player_phys *phys = &player.phys;
  29
  30    mdl_keyframe apose[32], bpose[32];
  31    struct skeleton *sk = &player.mdl.sk;
  32
  33    if( player.walk > 0.025f )
  34    {
  35       /* TODO move */
  36       float walk_norm = 30.0f/(float)player.mdl.anim_walk->length,
  37             run_norm  = 30.0f/(float)player.mdl.anim_run->length,
  38             walk_adv  = vg_lerpf( walk_norm, run_norm, player.walk );
  39
  40       player.walk_timer += walk_adv * vg.time_delta;
  41    }
  42    else
  43    {
  44       player.walk_timer = 0.0f;
  45    }
  46
  47    float walk_norm = (float)player.mdl.anim_walk->length/30.0f,
  48          run_norm  = (float)player.mdl.anim_run->length/30.0f,
  49          t = player.walk_timer,
  50          l = vg_clampf( player.frun*15.0f, 0.0f, 1.0f ),
  51          idle_walk = vg_clampf( (player.frun-0.1f)/(1.0f-0.1f), 0.0f, 1.0f );
  52
  53    /* walk/run */
  54    skeleton_sample_anim( sk, player.mdl.anim_walk, t*walk_norm, apose );
  55    skeleton_sample_anim( sk, player.mdl.anim_run,  t*run_norm, bpose );
  56
  57    skeleton_lerp_pose( sk, apose, bpose, l, apose );
  58
  59    /* idle */
  60    skeleton_sample_anim( sk, player.mdl.anim_idle, vg.time*0.1f, bpose );
  61    skeleton_lerp_pose( sk, apose, bpose, 1.0f-idle_walk, apose );
  62
  63    /* air */
  64    skeleton_sample_anim( sk, player.mdl.anim_jump, vg.time*0.6f, bpose );
  65    skeleton_lerp_pose( sk, apose, bpose, player.ffly, apose );
  66
  67    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_defer_ik );
  68    skeleton_apply_ik_pass( &player.mdl.sk );
  69    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_deffered_only );
  70
  71    v3_copy( player.mdl.sk.final_mtx[player.mdl.id_head-1][3],
  72                player.mdl.cam_pos );
  73
  74    skeleton_apply_inverses( &player.mdl.sk );
  75
  76    m4x3f mtx;
  77    v4f rot;
  78    q_axis_angle( rot, (v3f){0.0f,1.0f,0.0f}, -player.angles[0] - VG_PIf*0.5f );
  79    q_m3x3( rot, mtx );
  80    v3_copy( player.visual_transform[3], mtx[3] );
  81
  82    skeleton_apply_transform( &player.mdl.sk, mtx );
  83    skeleton_debug( &player.mdl.sk );
  84 }
  85
  86 VG_STATIC void player_animate(void)
  87 {
  88    struct player_phys *phys = &player.phys;
  89    rb_extrapolate_transform( &player.phys.rb, player.visual_transform );
  90    v3_muladds( player.visual_transform[3], phys->rb.up, -0.2f,
  91                player.visual_transform[3] );
  92
  93    v4f qfake_rot;
  94    m3x3f fake_rot;
  95    float substep = vg_clampf( vg.accumulator / VG_TIMESTEP_FIXED, 0.0f, 1.0f );
  96    q_axis_angle( qfake_rot, phys->rb.up, phys->siY*substep );
  97    q_m3x3( qfake_rot, fake_rot );
  98    m3x3_mul( fake_rot, player.visual_transform, player.visual_transform );
  99
 100    m4x3_invert_affine( player.visual_transform, player.inv_visual_transform );
 101
 102    if( !phys->on_board )
 103    {
 104       player_animate_offboard();
 105       return;
 106    }
 107
 108    /* Camera position */
 109    v3_muladds( phys->m, phys->a, VG_TIMESTEP_FIXED, phys->m );
 110    v3_lerp( phys->m, (v3f){0.0f,0.0f,0.0f}, 0.1f, phys->m );
 111
 112    phys->m[0] = vg_clampf( phys->m[0], -2.0f, 2.0f );
 113    phys->m[1] = vg_clampf( phys->m[1], -2.0f, 2.0f );
 114    phys->m[2] = vg_clampf( phys->m[2], -2.0f, 2.0f );
 115    v3_lerp( phys->bob, phys->m, 0.2f, phys->bob );
 116
 117    /* Head */
 118    float lslip = fabsf(phys->slip);
 119
 120    float kheight = 2.0f,
 121          kleg = 0.6f;
 122
 123    v3f offset;
 124    v3_zero( offset );
 125    m3x3_mulv( player.inv_visual_transform, phys->bob, offset );
 126
 127    static float speed_wobble = 0.0f, speed_wobble_2 = 0.0f;
 128
 129    float kickspeed = vg_clampf(v3_length(phys->rb.v)*(1.0f/40.0f), 0.0f, 1.0f);
 130    float kicks = (vg_randf()-0.5f)*2.0f*kickspeed;
 131    float sign = vg_signf( kicks );
 132    speed_wobble = vg_lerpf( speed_wobble, kicks*kicks*sign, 6.0f*vg.time_delta);
 133    speed_wobble_2 = vg_lerpf( speed_wobble_2, speed_wobble, 2.4f*vg.time_delta);
 134
 135    offset[0] *= 0.26f;
 136    offset[0] += speed_wobble_2*3.0f;
 137
 138    offset[1] *= -0.3f;
 139    offset[2] *= 0.01f;
 140
 141    offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(player.fslide)*0.9f);
 142    offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
 143
 144    /*
 145     * Animation blending
 146     * ===========================================
 147     */
 148
 149    /* scalar blending information */
 150    float speed = v3_length( phys->rb.v );
 151
 152    /* sliding */
 153    {
 154       float desired = vg_clampf( lslip, 0.0f, 1.0f );
 155       player.fslide = vg_lerpf( player.fslide, desired, 2.4f*vg.time_delta);
 156    }
 157
 158    /* movement information */
 159    {
 160       float dirz = phys->reverse > 0.0f? 0.0f: 1.0f,
 161             dirx = phys->slip < 0.0f?    0.0f: 1.0f,
 162             fly  = (phys->in_air|phys->grind)?  1.0f: 0.0f;
 163
 164       player.fdirz = vg_lerpf( player.fdirz, dirz, 2.4f*vg.time_delta );
 165       player.fdirx = vg_lerpf( player.fdirx, dirx, 0.6f*vg.time_delta );
 166       player.ffly  = vg_lerpf( player.ffly, fly,   2.4f*vg.time_delta );
 167    }
 168
 169    struct skeleton *sk = &player.mdl.sk;
 170
 171    mdl_keyframe apose[32], bpose[32];
 172    mdl_keyframe ground_pose[32];
 173    {
 174       /* when the player is moving fast he will crouch down a little bit */
 175       float stand = 1.0f - vg_clampf( speed * 0.03f, 0.0f, 1.0f );
 176       player.fstand = vg_lerpf( player.fstand, stand, 6.0f*vg.time_delta );
 177
 178       /* stand/crouch */
 179       float dir_frame   = player.fdirz * (15.0f/30.0f),
 180             stand_blend = offset[1]*-2.0f;
 181
 182       v3f local_cog;
 183       m4x3_mulv( player.phys.rb.to_local, player.phys.cog, local_cog );
 184
 185       stand_blend = vg_clampf( 1.0f-local_cog[1], 0, 1 );
 186
 187       skeleton_sample_anim( sk, player.mdl.anim_stand, dir_frame, apose );
 188       skeleton_sample_anim( sk, player.mdl.anim_highg, dir_frame, bpose );
 189       skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
 190
 191       /* sliding */
 192       float slide_frame = player.fdirx * (15.0f/30.0f);
 193       skeleton_sample_anim( sk, player.mdl.anim_slide, slide_frame, bpose );
 194       skeleton_lerp_pose( sk, apose, bpose, player.fslide, apose );
 195
 196       /* pushing */
 197       player.fpush = vg_lerpf( player.fpush,
 198                                player.phys.pushing,
 199                                6.0f*vg.time_delta );
 200
 201       float pt = player.phys.push_time + vg.accumulator;
 202       if( phys->reverse > 0.0f )
 203          skeleton_sample_anim( sk, player.mdl.anim_push, pt, bpose );
 204       else
 205          skeleton_sample_anim( sk, player.mdl.anim_push_reverse, pt, bpose );
 206
 207       skeleton_lerp_pose( sk, apose, bpose, player.fpush, apose );
 208
 209       /* trick setup */
 210       float jump_start_frame = 14.0f/30.0f;
 211
 212       player.fjump = vg_lerpf( player.fjump, phys->jump, 8.4f*vg.time_delta );
 213
 214       float setup_frame = phys->jump * jump_start_frame,
 215             setup_blend = vg_minf( player.fjump, 1.0f );
 216
 217       float jump_frame = (vg.time - player.jump_time) + jump_start_frame;
 218       if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
 219          setup_frame = jump_frame;
 220
 221       struct skeleton_anim *jump_anim = phys->jump_dir?
 222                                         player.mdl.anim_ollie:
 223                                         player.mdl.anim_ollie_reverse;
 224
 225       skeleton_sample_anim_clamped( sk, jump_anim, setup_frame, bpose );
 226       skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
 227    }
 228
 229    mdl_keyframe air_pose[32];
 230    {
 231       float target = -player.input_js1h->axis.value;
 232       player.fairdir = vg_lerpf( player.fairdir, target, 2.4f*vg.time_delta );
 233
 234       float air_frame = (player.fairdir*0.5f+0.5f) * (15.0f/30.0f);
 235
 236       skeleton_sample_anim( sk, player.mdl.anim_air, air_frame, apose );
 237
 238       static v2f grab_choice;
 239
 240       v2f grab_input = { player.input_js2h->axis.value,
 241                          player.input_js2v->axis.value };
 242       v2_add( player.phys.grab_mouse_delta, grab_input, grab_input );
 243       if( v2_length2( grab_input ) <= 0.001f )
 244          grab_input[0] = -1.0f;
 245       else
 246          v2_normalize_clamp( grab_input );
 247       v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice );
 248
 249       float ang = atan2f( grab_choice[0], grab_choice[1] ),
 250             ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
 251             grab_frame = ang_unit * (15.0f/30.0f);
 252
 253       skeleton_sample_anim( sk, player.mdl.anim_grabs, grab_frame, bpose );
 254       skeleton_lerp_pose( sk, apose, bpose, phys->grab, air_pose );
 255    }
 256
 257    skeleton_lerp_pose( sk, ground_pose, air_pose, player.ffly, apose );
 258
 259    float add_grab_mod = 1.0f - player.ffly;//*phys->grab;
 260
 261    /* additive effects */
 262    {
 263       u32 apply_to[] = { player.mdl.id_hip,
 264                          player.mdl.id_ik_hand_l,
 265                          player.mdl.id_ik_hand_r,
 266                          player.mdl.id_ik_elbow_l,
 267                          player.mdl.id_ik_elbow_r };
 268
 269       for( int i=0; i<vg_list_size(apply_to); i ++ )
 270       {
 271          apose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod;
 272          apose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod;
 273       }
 274
 275       v3f bo;
 276       v3_muls( player.board_offset, add_grab_mod, bo );
 277
 278       v3_add( bo, apose[ player.mdl.id_board-1 ].co,
 279                                    apose[ player.mdl.id_board-1 ].co );
 280       v3_add( bo, apose[ player.mdl.id_ik_foot_l-1 ].co,
 281                                    apose[ player.mdl.id_ik_foot_l-1 ].co );
 282       v3_add( bo, apose[ player.mdl.id_ik_foot_r-1 ].co,
 283                                    apose[ player.mdl.id_ik_foot_r-1 ].co );
 284
 285       m3x3f c;
 286       q_m3x3( player.board_rotation, c );
 287
 288       v3f d;
 289       v3_sub( apose[ player.mdl.id_ik_foot_l-1 ].co, bo, d );
 290       m3x3_mulv( c, d, d );
 291       v3_add( bo, d, apose[ player.mdl.id_ik_foot_l-1 ].co );
 292
 293       v3_sub( apose[ player.mdl.id_ik_foot_r-1 ].co, bo, d );
 294       m3x3_mulv( c, d, d );
 295       v3_add( bo, d, apose[ player.mdl.id_ik_foot_r-1 ].co );
 296
 297       q_mul(  player.board_rotation, apose[ player.mdl.id_board-1 ].q ,
 298              apose[ player.mdl.id_board-1 ].q );
 299       q_normalize( apose[ player.mdl.id_board-1 ].q );
 300    }
 301
 302    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_defer_ik );
 303    skeleton_apply_ik_pass( &player.mdl.sk );
 304    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_deffered_only );
 305
 306    v3_copy( player.mdl.sk.final_mtx[player.mdl.id_head-1][3],
 307                player.mdl.cam_pos );
 308    skeleton_apply_inverses( &player.mdl.sk );
 309    skeleton_apply_transform( &player.mdl.sk, player.visual_transform );
 310
 311    skeleton_debug( &player.mdl.sk );
 312 }
 313
 314 VG_STATIC void player_animate_death_cam(void)
 315 {
 316    v3f delta;
 317    v3f head_pos;
 318    v3_copy( player.mdl.ragdoll[0].rb.co, head_pos );
 319
 320    v3_sub( head_pos, player.camera_pos, delta );
 321    v3_normalize( delta );
 322
 323    v3f follow_pos;
 324    v3_muladds( head_pos, delta, -2.5f, follow_pos );
 325    v3_lerp( player.camera_pos, follow_pos, 0.1f, player.camera_pos );
 326
 327    /*
 328     * Make sure the camera stays above the ground
 329     */
 330    v3f min_height = {0.0f,1.0f,0.0f};
 331
 332    v3f sample;
 333    v3_add( player.camera_pos, min_height, sample );
 334    ray_hit hit;
 335    hit.dist = min_height[1]*2.0f;
 336
 337    if( ray_world( sample, (v3f){0.0f,-1.0f,0.0f}, &hit ))
 338       v3_add( hit.pos, min_height, player.camera_pos );
 339
 340    if( world.water.enabled )
 341    {
 342       player.camera_pos[1] =
 343          vg_maxf( world.water.height + 2.0f, player.camera_pos[1] );
 344    }
 345
 346    player.angles[0] = atan2f( delta[0], -delta[2] );
 347    player.angles[1] = -asinf( delta[1] );
 348 }
 349
 350 VG_STATIC void player_animate_follow_cam( v3f target, float dist, float speed )
 351 {
 352    v3f delta;
 353
 354    v3_sub( target, player.camera_pos, delta );
 355    v3_normalize( delta );
 356
 357    v3f follow_pos;
 358    v3_muladds( target, delta, -dist, follow_pos );
 359    v3_lerp( player.camera_pos, follow_pos,
 360              speed * vg.time_delta, player.camera_pos );
 361
 362    /*
 363     * Make sure the camera stays above the ground
 364     */
 365    v3f min_height = {0.0f,1.0f,0.0f};
 366
 367    v3f sample;
 368    v3_add( player.camera_pos, min_height, sample );
 369    ray_hit hit;
 370    hit.dist = min_height[1]*2.0f;
 371
 372    if( ray_world( sample, (v3f){0.0f,-1.0f,0.0f}, &hit ))
 373       v3_add( hit.pos, min_height, player.camera_pos );
 374
 375 #if 0
 376    if( world.water.enabled )
 377    {
 378       player.camera_pos[1] =
 379          vg_maxf( world.water.height + 2.0f, player.camera_pos[1] );
 380    }
 381 #endif
 382
 383    player.angles[0] = atan2f( delta[0], -delta[2] );
 384    player.angles[1] = -asinf( delta[1] );
 385 }
 386
 387 VG_STATIC void player_animate_camera_thirdperson(void)
 388 {
 389    static v3f lerp_cam = { 0.0f, 0.0f, 0.0f };
 390    v3f target;
 391
 392    v3_muladds( player.phys.rb.co, player.phys.rb.up, 1.2f, target );
 393
 394    player_animate_follow_cam( target, 1.5f, 20.0f );
 395 }
 396
 397 VG_STATIC void player_animate_camera(void)
 398 {
 399    struct player_phys *phys = &player.phys;
 400
 401    static v3f lerp_cam = {0.0f,0.0f,0.0f};
 402    v3f cam_pos;
 403
 404    player.fonboard = vg_lerpf( player.fonboard, phys->on_board, vg.time_delta );
 405
 406    if( phys->on_board )
 407    {
 408       v3f offs = { -0.4f, 0.15f, 0.0f };
 409       v3_lerp( lerp_cam, player.mdl.cam_pos, 0.8f, lerp_cam );
 410       v3_add( lerp_cam, offs, cam_pos );
 411
 412       /* Look angles */
 413       v3_lerp( phys->vl, phys->rb.v, 0.05f, phys->vl );
 414
 415       player.fgrind = vg_lerpf( player.fgrind, phys->grind, vg.time_delta );
 416
 417       float yaw = atan2f(  phys->vl[0], -phys->vl[2] ),
 418           pitch = atan2f
 419                   (
 420                       -phys->vl[1],
 421                       sqrtf
 422                       (
 423                         phys->vl[0]*phys->vl[0] + phys->vl[2]*phys->vl[2]
 424                       )
 425                   )
 426                   * 0.7f + vg_lerpf( 0.30f, 0.90f, player.fgrind );
 427
 428       player.angles[0] = yaw;
 429       player.angles[1] = vg_lerpf( player.angles[1], pitch, player.fonboard );
 430
 431       /* Camera shake */
 432       static v2f shake_damp = {0.0f,0.0f};
 433       v2f shake = { vg_randf()-0.5f, vg_randf()-0.5f };
 434       v2_muls( shake, v3_length(phys->rb.v)*0.3f
 435                            * (1.0f+fabsf(phys->slip)), shake);
 436
 437       v2_lerp( shake_damp, shake, 0.01f, shake_damp );
 438       shake_damp[0] *= 0.2f;
 439
 440       v2_muladds( player.angles, shake_damp, 0.1f, player.angles );
 441       m4x3_mulv( player.visual_transform, cam_pos, player.camera_pos );
 442    }
 443    else
 444    {
 445       float speed = vg.time_delta * k_look_speed;
 446 #if 0
 447       player.angles[0] += vg_get_axis( "lookh" ) * speed;
 448       player.angles[1] += vg_get_axis( "lookv" ) * speed;
 449
 450       player.angles[1] = vg_clampf( player.angles[1],
 451                                        -k_pitch_limit, k_pitch_limit );
 452 #endif
 453
 454       float s =  sinf(player.angles[0]) * 0.2f,
 455             c = -cosf(player.angles[0]) * 0.2f;
 456       v3f forward_dir = { s,0.15f,c };
 457
 458
 459       m4x3f mtx;
 460       v4f rot;
 461       q_axis_angle( rot, (v3f){0.0f,1.0f,0.0f},
 462                               -player.angles[0] -VG_PIf*0.5f );
 463       q_m3x3( rot, mtx );
 464       v3_copy( player.visual_transform[3], mtx[3] );
 465
 466       m4x3_mulv( mtx, player.mdl.cam_pos, cam_pos );
 467       v3_add( cam_pos, forward_dir, player.camera_pos );
 468       v3_lerp( phys->vl, phys->rb.v, 18.0f*vg.time_delta, phys->vl );
 469    }
 470 }
 471
 472 #endif /* PLAYER_ANIMATION_H */