player_common.c

   1 #ifndef PLAYER_COMMON_C
   2 #define PLAYER_COMMON_C
   3
   4 #include "player.h"
   5
   6 VG_STATIC void player_vector_angles( v3f angles, v3f v, float C, float k )
   7 {
   8    float yaw = atan2f( v[0], -v[2] ),
   9        pitch = atan2f
  10                (
  11                    -v[1],
  12                    sqrtf
  13                    (
  14                      v[0]*v[0] + v[2]*v[2]
  15                    )
  16                ) * C + k;
  17
  18    angles[0] = yaw;
  19    angles[1] = pitch;
  20 }
  21
  22 VG_STATIC void player_camera_portal_correction( player_instance *player )
  23 {
  24    if( player->gate_waiting )
  25    {
  26       /* construct plane equation for reciever gate */
  27       v4f plane;
  28       v3_copy( player->gate_waiting->recv_to_world[2], plane );
  29       plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
  30
  31       /* check camera polarity */
  32       if( v3_dot( player->cam.pos, plane ) < plane[3] )
  33       {
  34          vg_success( "Plane cleared\n" );
  35          player_apply_transport_to_cam( player->gate_waiting->transport );
  36          player->gate_waiting = NULL;
  37       }
  38       else
  39       {
  40          /* de-transform camera and player back */
  41          m4x3f inverse;
  42          m4x3_invert_affine( player->gate_waiting->transport, inverse );
  43          m4x3_mulv( inverse, player->cam.pos, player->cam.pos );
  44
  45          /* TODO: Find robust method for this */
  46          v3f fwd_dir = { cosf(player->cam.angles[0]),
  47                          0.0f,
  48                          sinf(player->cam.angles[0])};
  49          m3x3_mulv( inverse, fwd_dir, fwd_dir );
  50          player->cam.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
  51
  52          struct skeleton *sk = &player->playeravatar->sk;
  53          skeleton_apply_transform( sk, inverse );
  54       }
  55    }
  56 }
  57
  58 VG_STATIC void player__cam_iterate( player_instance *player )
  59 {
  60    struct player_avatar *av = player->playeravatar;
  61
  62    v3_lerp( player->follow_pos, player->follow_pos_target,
  63             vg.frame_delta * 15.0f, player->follow_pos );
  64    camera_lerp_angles( player->follow_angles, player->follow_angles_target,
  65             vg.frame_delta * 18.0f, player->follow_angles );
  66
  67    /* Blending */
  68    player->camera_type_blend =
  69       vg_lerpf( player->camera_type_blend,
  70                 (player->camera_mode == k_cam_firstperson)? 1.0f: 0.0f,
  71                 5.0f * vg.frame_delta );
  72    float t = player->camera_type_blend;
  73
  74    v3f p0, p1, a0, a1;
  75    v3_lerp( player->follow_pos, player->override_pos,
  76             player->cam_position_override_strength, p1 );
  77    camera_lerp_angles( player->follow_angles, player->override_angles,
  78             player->cam_angles_override_strength, a1 );
  79
  80    v3_copy( player->fpv_pos, p0 );
  81    v3_copy( player->fpv_angles, a0 );
  82
  83    v3_lerp( p0, p1, player->camera_type_blend, player->cam.pos );
  84    camera_lerp_angles( a0, a1, player->camera_type_blend, player->cam.angles );
  85
  86    /* FIXME: cl_fov */
  87    player->cam.fov = vg_lerpf( 118.0f, 90.0f, player->camera_type_blend );
  88
  89    /* portal transitions */
  90    player_camera_portal_correction( player );
  91 }
  92
  93 VG_STATIC void player_set_follower_subject( player_instance *player,
  94                                             v3f subj )
  95 {
  96    v3f dir;
  97    v3_sub( subj, player->follow_pos, dir );
  98
  99    if( v3_length2( dir ) < 0.1f*0.1f )
 100       v3_copy( (v3f){ 0.0f, 0.0f, 1.0f }, dir );   /* FIXME */
 101    else
 102       v3_normalize( dir );
 103
 104    dir[1] *= 0.0f;
 105
 106    v3_muladds( subj, dir, -2.0f, player->follow_pos_target );
 107    player_vector_angles( player->follow_angles_target, dir, 1.0f, 0.2f );
 108 }
 109
 110 VG_STATIC void player_look( player_instance *player, v3f angles )
 111 {
 112    angles[2] = 0.0f;
 113    v2_muladds( angles, vg.mouse_delta, 0.0025f, angles );
 114
 115    if( vg_input.controller_should_use_trackpad_look )
 116    {
 117       static v2f last_input;
 118       static v2f vel;
 119       static v2f vel_smooth;
 120
 121       v2f input = { player->input_js2h->axis.value,
 122                     player->input_js2v->axis.value };
 123
 124       if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) )
 125       {
 126          v2_sub( input, last_input, vel );
 127          v2_muls( vel, 1.0f/vg.time_delta, vel );
 128       }
 129       else
 130       {
 131          v2_zero( vel );
 132       }
 133
 134       v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
 135
 136       v2_muladds( angles, vel_smooth, vg.time_delta, angles );
 137       v2_copy( input, last_input );
 138    }
 139    else
 140    {
 141       angles[0] += player->input_js2h->axis.value * vg.time_delta * 4.0f;
 142       angles[1] += player->input_js2v->axis.value * vg.time_delta * 4.0f;
 143    }
 144
 145    angles[1] = vg_clampf( angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
 146 }
 147
 148 #endif /* PLAYER_COMMON_C */