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