X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_animation.h;h=08a540554bf5f0577fb6e9c2ce9a1b2c563faf5d;hb=2a238d32da833812e837cf38e16a7685c98db5c3;hp=101bd22e50bd8335c7a0eebcd4e501e47aba61d1;hpb=2ca677a0ec9d00db46a8b97bec30dbea8280a79b;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_animation.h b/player_animation.h
index 101bd22..08a5405 100644
--- a/player_animation.h
+++ b/player_animation.h
@@ -1,28 +1,69 @@
+/*
+ * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ */
+
 #ifndef PLAYER_ANIMATION_H
 #define PLAYER_ANIMATION_H
 
 #include "player.h"
 
-static void player_animate_offboard(void)
+VG_STATIC void player_animate_offboard(void)
 {
+   {
+      float fly = player.phys.in_air,
+            rate;
+
+      if( player.phys.in_air )
+         rate = 2.4f;
+      else
+         rate = 9.0f;
+
+      player.ffly  = vg_lerpf( player.ffly, fly, rate*vg.time_delta );
+      player.frun  = vg_lerpf( player.frun,
+                               player.walk *
+                               (1.0f + player.input_walk->button.value*0.5f),
+                               2.0f*vg.time_delta );
+   }
+
+   struct player_phys *phys = &player.phys;
+
    mdl_keyframe apose[32], bpose[32];
    struct skeleton *sk = &player.mdl.sk;
 
+   if( player.walk > 0.025f )
+   {
+      /* TODO move */
+      float walk_norm = 30.0f/(float)player.mdl.anim_walk->length,
+            run_norm  = 30.0f/(float)player.mdl.anim_run->length,
+            walk_adv  = vg_lerpf( walk_norm, run_norm, player.walk );
+
+      player.walk_timer += walk_adv * vg.time_delta;
+   }
+   else
+   {
+      player.walk_timer = 0.0f;
+   }
+
    float walk_norm = (float)player.mdl.anim_walk->length/30.0f,
          run_norm  = (float)player.mdl.anim_run->length/30.0f,
          t = player.walk_timer,
-         l = vg_get_axis("grabr") * 0.5f + 0.5f;
+         l = vg_clampf( player.frun*15.0f, 0.0f, 1.0f ),
+         idle_walk = vg_clampf( (player.frun-0.1f)/(1.0f-0.1f), 0.0f, 1.0f );
 
+   /* walk/run */
    skeleton_sample_anim( sk, player.mdl.anim_walk, t*walk_norm, apose );
    skeleton_sample_anim( sk, player.mdl.anim_run,  t*run_norm, bpose );
 
    skeleton_lerp_pose( sk, apose, bpose, l, apose );
 
-   float idle_walk = vg_minf( l * 10.0f, 1.0f);
-
-   skeleton_sample_anim( sk, player.mdl.anim_idle, vg_time*0.1f, bpose );
+   /* idle */
+   skeleton_sample_anim( sk, player.mdl.anim_idle, vg.time*0.1f, bpose );
    skeleton_lerp_pose( sk, apose, bpose, 1.0f-idle_walk, apose );
 
+   /* air */
+   skeleton_sample_anim( sk, player.mdl.anim_jump, vg.time*0.6f, bpose );
+   skeleton_lerp_pose( sk, apose, bpose, player.ffly, apose );
+
    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_defer_ik );
    skeleton_apply_ik_pass( &player.mdl.sk );
    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_deffered_only );
@@ -36,49 +77,63 @@ static void player_animate_offboard(void)
    v4f rot;
    q_axis_angle( rot, (v3f){0.0f,1.0f,0.0f}, -player.angles[0] - VG_PIf*0.5f );
    q_m3x3( rot, mtx );
-   v3_copy( player.rb.to_world[3], mtx[3] );
+   v3_copy( player.visual_transform[3], mtx[3] );
 
    skeleton_apply_transform( &player.mdl.sk, mtx );
    skeleton_debug( &player.mdl.sk );
 }
 
-static void player_animate(void)
+VG_STATIC void player_animate(void)
 {
-   if( !player.on_board )
+   struct player_phys *phys = &player.phys;
+   rb_extrapolate_transform( &player.phys.rb, player.visual_transform );
+   v3_muladds( player.visual_transform[3], phys->rb.up, -0.2f, 
+               player.visual_transform[3] );
+
+   v4f qfake_rot;
+   m3x3f fake_rot;
+   float substep = vg_clampf( vg.accumulator / VG_TIMESTEP_FIXED, 0.0f, 1.0f );
+   q_axis_angle( qfake_rot, phys->rb.up, phys->siY*substep );
+   q_m3x3( qfake_rot, fake_rot );
+   m3x3_mul( fake_rot, player.visual_transform, player.visual_transform );
+
+   m4x3_invert_affine( player.visual_transform, player.inv_visual_transform );
+
+   if( !phys->on_board )
    {
       player_animate_offboard();
       return;
    }
 
    /* Camera position */
-   v3_sub( player.rb.v, player.v_last, player.a );
-   v3_copy( player.rb.v, player.v_last );
+   v3_sub( phys->rb.v, phys->v_last, phys->a );
+   v3_copy( phys->rb.v, phys->v_last );
 
-   v3_add( player.m, player.a, player.m );
-   v3_lerp( player.m, (v3f){0.0f,0.0f,0.0f}, 0.1f, player.m );
+   v3_add( phys->m, phys->a, phys->m );
+   v3_lerp( phys->m, (v3f){0.0f,0.0f,0.0f}, 0.1f, phys->m );
 
-   player.m[0] = vg_clampf( player.m[0], -2.0f, 2.0f );
-   player.m[1] = vg_clampf( player.m[1], -2.0f, 2.0f );
-   player.m[2] = vg_clampf( player.m[2], -2.0f, 2.0f );
-   v3_lerp( player.bob, player.m, 0.2f, player.bob );
+   phys->m[0] = vg_clampf( phys->m[0], -2.0f, 2.0f );
+   phys->m[1] = vg_clampf( phys->m[1], -2.0f, 2.0f );
+   phys->m[2] = vg_clampf( phys->m[2], -2.0f, 2.0f );
+   v3_lerp( phys->bob, phys->m, 0.2f, phys->bob );
 
    /* Head */
-   float lslip = fabsf(player.slip);
+   float lslip = fabsf(phys->slip);
 
    float kheight = 2.0f,
          kleg = 0.6f;
 
    v3f offset;
    v3_zero( offset );
-   m3x3_mulv( player.rb.to_local, player.bob, offset );
+   m3x3_mulv( player.inv_visual_transform, phys->bob, offset );
 
    static float speed_wobble = 0.0f, speed_wobble_2 = 0.0f;
    
-   float kickspeed = vg_clampf(v3_length(player.rb.v)*(1.0f/40.0f), 0.0f, 1.0f);
+   float kickspeed = vg_clampf(v3_length(phys->rb.v)*(1.0f/40.0f), 0.0f, 1.0f);
    float kicks = (vg_randf()-0.5f)*2.0f*kickspeed;
    float sign = vg_signf( kicks );
-   speed_wobble = vg_lerpf( speed_wobble, kicks*kicks*sign, 0.1f );
-   speed_wobble_2 = vg_lerpf( speed_wobble_2, speed_wobble, 0.04f );
+   speed_wobble = vg_lerpf( speed_wobble, kicks*kicks*sign, 6.0f*vg.time_delta);
+   speed_wobble_2 = vg_lerpf( speed_wobble_2, speed_wobble, 2.4f*vg.time_delta);
 
    offset[0] *= 0.26f;
    offset[0] += speed_wobble_2*3.0f;
@@ -86,8 +141,8 @@ static void player_animate(void)
    offset[1] *= -0.3f;
    offset[2] *= 0.01f;
 
-   offset[0] = vg_clampf( offset[0], -0.8f, 0.8f );
-   offset[1] = vg_clampf( offset[1], -0.5f, 0.0f );
+   offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(player.fslide)*0.9f);
+   offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
 
    /* 
     * Animation blending
@@ -95,23 +150,23 @@ static void player_animate(void)
     */
 
    /* scalar blending information */
-   float speed = v3_length( player.rb.v );
+   float speed = v3_length( phys->rb.v );
    
    /* sliding */
    {
       float desired = vg_clampf( lslip, 0.0f, 1.0f );
-      player.fslide = vg_lerpf( player.fslide, desired, 0.04f );
+      player.fslide = vg_lerpf( player.fslide, desired, 2.4f*vg.time_delta);
    }
    
    /* movement information */
    {
-      float dirz = player.reverse > 0.0f? 0.0f: 1.0f,
-            dirx = player.slip < 0.0f?    0.0f: 1.0f,
-            fly  = player.in_air?         1.0f: 0.0f;
+      float dirz = phys->reverse > 0.0f? 0.0f: 1.0f,
+            dirx = phys->slip < 0.0f?    0.0f: 1.0f,
+            fly  = (phys->in_air|phys->grind)?  1.0f: 0.0f;
 
-      player.fdirz = vg_lerpf( player.fdirz, dirz, 0.04f );
-      player.fdirx = vg_lerpf( player.fdirx, dirx, 0.01f );
-      player.ffly  = vg_lerpf( player.ffly, fly, 0.04f );
+      player.fdirz = vg_lerpf( player.fdirz, dirz, 2.4f*vg.time_delta );
+      player.fdirx = vg_lerpf( player.fdirx, dirx, 0.6f*vg.time_delta );
+      player.ffly  = vg_lerpf( player.ffly, fly,   2.4f*vg.time_delta );
    }
    
    struct skeleton *sk = &player.mdl.sk;
@@ -121,7 +176,7 @@ static void player_animate(void)
    {
       /* when the player is moving fast he will crouch down a little bit */
       float stand = 1.0f - vg_clampf( speed * 0.03f, 0.0f, 1.0f );
-      player.fstand = vg_lerpf( player.fstand, stand, 0.1f );
+      player.fstand = vg_lerpf( player.fstand, stand, 6.0f*vg.time_delta );
 
       /* stand/crouch */
       float dir_frame   = player.fdirz * (15.0f/30.0f),
@@ -137,10 +192,12 @@ static void player_animate(void)
       skeleton_lerp_pose( sk, apose, bpose, player.fslide, apose );
 
       /* pushing */
-      player.fpush = vg_lerpf( player.fpush, player.pushing, 0.1f );
+      player.fpush = vg_lerpf( player.fpush, 
+                               player.phys.pushing, 
+                               6.0f*vg.time_delta );
 
-      float pt = player.push_time;
-      if( player.reverse > 0.0f )
+      float pt = player.phys.push_time + vg.accumulator;
+      if( phys->reverse > 0.0f )
          skeleton_sample_anim( sk, player.mdl.anim_push, pt, bpose );
       else
          skeleton_sample_anim( sk, player.mdl.anim_push_reverse, pt, bpose );
@@ -149,14 +206,17 @@ static void player_animate(void)
 
       /* trick setup */
       float jump_start_frame = 14.0f/30.0f;
-      float setup_frame = player.jump * jump_start_frame,
-            setup_blend = vg_minf( player.jump*5.0f, 1.0f );
+
+      player.fjump = vg_lerpf( player.fjump, phys->jump, 8.4f*vg.time_delta );
+
+      float setup_frame = phys->jump * jump_start_frame,
+            setup_blend = vg_minf( player.fjump, 1.0f );
       
-      float jump_frame = (vg_time - player.jump_time) + jump_start_frame;
+      float jump_frame = (vg.time - player.jump_time) + jump_start_frame;
       if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
          setup_frame = jump_frame;
 
-      struct skeleton_anim *jump_anim = player.jump_dir?
+      struct skeleton_anim *jump_anim = phys->jump_dir?
                                         player.mdl.anim_ollie:
                                         player.mdl.anim_ollie_reverse;
 
@@ -166,41 +226,51 @@ static void player_animate(void)
    
    mdl_keyframe air_pose[32];
    {
-      float target = -vg_get_axis("horizontal");
-      player.fairdir = vg_lerpf( player.fairdir, target, 0.04f );
+      float target = -player.input_js1h->axis.value;
+      player.fairdir = vg_lerpf( player.fairdir, target, 2.4f*vg.time_delta );
       
       float air_frame = (player.fairdir*0.5f+0.5f) * (15.0f/30.0f);
       
       skeleton_sample_anim( sk, player.mdl.anim_air, air_frame, apose );
 
       static v2f grab_choice;
-      v2_lerp( grab_choice, (v2f){ vg_get_axis("h1"), vg_get_axis("v1") },
-                            0.04f, grab_choice );
+
+      v2f grab_input = { player.input_js2h->axis.value,
+                         player.input_js2v->axis.value };
+      v2_add( player.phys.grab_mouse_delta, grab_input, grab_input );
+      if( v2_length2( grab_input ) <= 0.001f )
+         grab_input[0] = -1.0f;
+      else
+         v2_normalize_clamp( grab_input );
+      v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice );
 
       float ang = atan2f( grab_choice[0], grab_choice[1] ),
             ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
             grab_frame = ang_unit * (15.0f/30.0f);
 
       skeleton_sample_anim( sk, player.mdl.anim_grabs, grab_frame, bpose );
-      skeleton_lerp_pose( sk, apose, bpose, player.grab, air_pose );
+      skeleton_lerp_pose( sk, apose, bpose, phys->grab, air_pose );
    }
 
    skeleton_lerp_pose( sk, ground_pose, air_pose, player.ffly, apose );
 
-   float add_grab_mod = 1.0f - player.ffly*player.grab;
+   float add_grab_mod = 1.0f - player.ffly;//*phys->grab;
 
    /* additive effects */
-   apose[player.mdl.id_hip-1].co[0] += offset[0]*add_grab_mod;
-   apose[player.mdl.id_hip-1].co[2] += offset[2]*add_grab_mod;
-   apose[player.mdl.id_ik_hand_l-1].co[0] += offset[0]*add_grab_mod;
-   apose[player.mdl.id_ik_hand_l-1].co[2] += offset[2]*add_grab_mod;
-   apose[player.mdl.id_ik_hand_r-1].co[0] += offset[0]*add_grab_mod;
-   apose[player.mdl.id_ik_hand_r-1].co[2] += offset[2]*add_grab_mod;
-   apose[player.mdl.id_ik_elbow_l-1].co[0] += offset[0]*add_grab_mod;
-   apose[player.mdl.id_ik_elbow_l-1].co[2] += offset[2]*add_grab_mod;
-   apose[player.mdl.id_ik_elbow_r-1].co[0] += offset[0]*add_grab_mod;
-   apose[player.mdl.id_ik_elbow_r-1].co[2] += offset[2]*add_grab_mod;
-
+   {
+      u32 apply_to[] = { player.mdl.id_hip, 
+                         player.mdl.id_ik_hand_l,
+                         player.mdl.id_ik_hand_r,
+                         player.mdl.id_ik_elbow_l,
+                         player.mdl.id_ik_elbow_r };
+
+      for( int i=0; i<vg_list_size(apply_to); i ++ )
+      {
+         apose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod;
+         apose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod;
+      }
+   }
+   
    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_defer_ik );
    skeleton_apply_ik_pass( &player.mdl.sk );
    skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_deffered_only );
@@ -208,12 +278,12 @@ static void player_animate(void)
    v3_copy( player.mdl.sk.final_mtx[player.mdl.id_head-1][3], 
                player.mdl.cam_pos );
    skeleton_apply_inverses( &player.mdl.sk );
-   skeleton_apply_transform( &player.mdl.sk, player.rb.to_world );
+   skeleton_apply_transform( &player.mdl.sk, player.visual_transform );
 
    skeleton_debug( &player.mdl.sk );
 }
 
-static void player_animate_death_cam(void)
+VG_STATIC void player_animate_death_cam(void)
 {
    v3f delta;
    v3f head_pos;
@@ -239,59 +309,119 @@ static void player_animate_death_cam(void)
    if( ray_world( sample, (v3f){0.0f,-1.0f,0.0f}, &hit ))
       v3_add( hit.pos, min_height, player.camera_pos );
 
-   player.camera_pos[1] = 
-      vg_maxf( wrender.height + 2.0f, player.camera_pos[1] );
+   if( world.water.enabled )
+   {
+      player.camera_pos[1] = 
+         vg_maxf( world.water.height + 2.0f, player.camera_pos[1] );
+   }
+
+   player.angles[0] = atan2f( delta[0], -delta[2] ); 
+   player.angles[1] = -asinf( delta[1] );
+}
+
+VG_STATIC void player_animate_follow_cam( v3f target, float dist, float speed )
+{
+   v3f delta;
+
+   v3_sub( target, player.camera_pos, delta );
+   v3_normalize( delta );
+
+   v3f follow_pos;
+   v3_muladds( target, delta, -dist, follow_pos );
+   v3_lerp( player.camera_pos, follow_pos,
+             speed * vg.time_delta, player.camera_pos );
+
+   /* 
+    * Make sure the camera stays above the ground
+    */
+   v3f min_height = {0.0f,1.0f,0.0f};
+
+   v3f sample;
+   v3_add( player.camera_pos, min_height, sample );
+   ray_hit hit;
+   hit.dist = min_height[1]*2.0f;
+
+   if( ray_world( sample, (v3f){0.0f,-1.0f,0.0f}, &hit ))
+      v3_add( hit.pos, min_height, player.camera_pos );
+
+#if 0
+   if( world.water.enabled )
+   {
+      player.camera_pos[1] = 
+         vg_maxf( world.water.height + 2.0f, player.camera_pos[1] );
+   }
+#endif
 
    player.angles[0] = atan2f( delta[0], -delta[2] ); 
    player.angles[1] = -asinf( delta[1] );
 }
 
-static void player_animate_camera(void)
+VG_STATIC void player_animate_camera_thirdperson(void)
+{
+   static v3f lerp_cam = { 0.0f, 0.0f, 0.0f };
+   v3f target;
+   
+   v3_muladds( player.phys.rb.co, player.phys.rb.up, 1.2f, target );
+
+   player_animate_follow_cam( target, 1.5f, 20.0f );
+}
+
+VG_STATIC void player_animate_camera(void)
 {
+   struct player_phys *phys = &player.phys;
+
    static v3f lerp_cam = {0.0f,0.0f,0.0f};
    v3f cam_pos;
 
-   player.fonboard = vg_lerpf(player.fonboard, player.on_board, ktimestep*1.0f);
+   player.fonboard = vg_lerpf( player.fonboard, phys->on_board, vg.time_delta );
 
-   if( player.on_board )
+   if( phys->on_board )
    {
       v3f offs = { -0.4f, 0.15f, 0.0f };
       v3_lerp( lerp_cam, player.mdl.cam_pos, 0.8f, lerp_cam );
       v3_add( lerp_cam, offs, cam_pos );
 
       /* Look angles */
-      v3_lerp( player.vl, player.rb.v, 0.05f, player.vl );
+      v3_lerp( phys->vl, phys->rb.v, 0.05f, phys->vl );
+
+      player.fgrind = vg_lerpf( player.fgrind, phys->grind, vg.time_delta );
 
-      float yaw = atan2f(  player.vl[0], -player.vl[2] ),
-          pitch = atan2f( -player.vl[1], 
-                sqrtf(
-                  player.vl[0]*player.vl[0] + player.vl[2]*player.vl[2]
-                )) * 0.7f;
+      float yaw = atan2f(  phys->vl[0], -phys->vl[2] ),
+          pitch = atan2f
+                  ( 
+                      -phys->vl[1], 
+                      sqrtf
+                      (
+                        phys->vl[0]*phys->vl[0] + phys->vl[2]*phys->vl[2]
+                      )
+                  ) 
+                  * 0.7f + vg_lerpf( 0.30f, 0.90f, player.fgrind );
 
       player.angles[0] = yaw;
-      player.angles[1] = vg_lerpf( player.angles[1], pitch + 0.30f, 
-                                                         player.fonboard );
+      player.angles[1] = vg_lerpf( player.angles[1], pitch, player.fonboard );
 
       /* Camera shake */
       static v2f shake_damp = {0.0f,0.0f};
       v2f shake = { vg_randf()-0.5f, vg_randf()-0.5f };
-      v2_muls( shake, v3_length(player.rb.v)*0.3f 
-                           * (1.0f+fabsf(player.slip)), shake);
+      v2_muls( shake, v3_length(phys->rb.v)*0.3f 
+                           * (1.0f+fabsf(phys->slip)), shake);
 
       v2_lerp( shake_damp, shake, 0.01f, shake_damp );
       shake_damp[0] *= 0.2f;
 
       v2_muladds( player.angles, shake_damp, 0.1f, player.angles );
-      m4x3_mulv( player.rb.to_world, cam_pos, player.camera_pos );
+      m4x3_mulv( player.visual_transform, cam_pos, player.camera_pos );
    }
    else
    {
-      float speed = ktimestep * k_look_speed;
-      player.angles[0] += vg_get_axis( "horizontal" ) * speed;
-      player.angles[1] += vg_get_axis( "vertical" ) * speed;
+      float speed = vg.time_delta * k_look_speed;
+#if 0
+      player.angles[0] += vg_get_axis( "lookh" ) * speed;
+      player.angles[1] += vg_get_axis( "lookv" ) * speed;
       
       player.angles[1] = vg_clampf( player.angles[1], 
                                        -k_pitch_limit, k_pitch_limit );
+#endif
       
       float s =  sinf(player.angles[0]) * 0.2f,
             c = -cosf(player.angles[0]) * 0.2f;
@@ -303,11 +433,11 @@ static void player_animate_camera(void)
       q_axis_angle( rot, (v3f){0.0f,1.0f,0.0f}, 
                               -player.angles[0] -VG_PIf*0.5f );
       q_m3x3( rot, mtx );
-      v3_copy( player.rb.to_world[3], mtx[3] );
+      v3_copy( player.visual_transform[3], mtx[3] );
 
       m4x3_mulv( mtx, player.mdl.cam_pos, cam_pos );
       v3_add( cam_pos, forward_dir, player.camera_pos );
-      v3_lerp( player.vl, player.rb.v, 0.3f, player.vl );
+      v3_lerp( phys->vl, phys->rb.v, 18.0f*vg.time_delta, phys->vl );
    }
 }