/* TODO: Add back other logic thats normally here */
}
-VG_STATIC void player_camera_portal_correction( player_instance *player )
-{
- if( player->gate_waiting )
- {
- /* construct plane equation for reciever gate */
- v4f plane;
- v3_copy( player->gate_waiting->recv_to_world[2], plane );
- plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
-
- /* check camera polarity */
- if( v3_dot( player->cam.pos, plane ) < plane[3] )
- {
- vg_success( "Plane cleared\n" );
- player_apply_transport_to_cam( player->gate_waiting->transport );
- player->gate_waiting = NULL;
- }
- else
- {
- /* de-transform camera and player back */
- m4x3f inverse;
- m4x3_invert_affine( player->gate_waiting->transport, inverse );
- m4x3_mulv( inverse, player->cam.pos, player->cam.pos );
-
- /* TODO: Find robust method for this */
- v3f fwd_dir = { cosf(player->cam.angles[0]),
- 0.0f,
- sinf(player->cam.angles[0])};
- m3x3_mulv( inverse, fwd_dir, fwd_dir );
- player->cam.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
-
- struct skeleton *sk = &player->playeravatar->sk;
- skeleton_apply_transform( sk, inverse );
- }
- }
-}
-
VG_STATIC void player__pre_render( player_instance *player )
{
if( _player_animate[ player->subsystem ] )
if( _player_post_animate[ player->subsystem ] )
_player_post_animate[ player->subsystem ]( player );
- /* TODO: eventually, blending code goes here */
-
- float camera_blend_target = 1.0f;
- if( player->camera_mode == k_cam_firstperson )
- camera_blend_target = 0.0f;
-
- player->camera_type_blend = vg_lerpf( player->camera_type_blend,
- camera_blend_target,
- 5.0f * vg.frame_delta );
-
- float t = player->camera_type_blend;
- camera_lerp_angles( player->cam1.angles, player->cam3.angles,
- t, player->cam.angles );
- v3_lerp( player->cam1.co, player->cam3.co, t, player->cam.pos );
- player->cam.fov = vg_lerpf( 118.0f, 90.0f, t );
-
- player_camera_portal_correction( player );
+ player__cam_iterate( player );
}
PLAYER_API void player__render( camera *cam, player_instance *player )
camera_mode;
float camera_type_blend;
+#if 0
struct
{
v3f co, angles;
}
cam1, cam3;
+#endif
+
+ v3f follow_pos,
+ follow_angles,
+ follow_pos_target,
+ follow_angles_target,
+ override_pos,
+ override_angles,
+ fpv_pos,
+ fpv_angles;
+
+ float cam_position_override_strength,
+ cam_angles_override_strength;
teleport_gate *gate_waiting;
#include "player.h"
-void player_look( player_instance *player, v3f angles )
+VG_STATIC void player_vector_angles( v3f angles, v3f v, float C, float k )
+{
+ float yaw = atan2f( v[0], -v[2] ),
+ pitch = atan2f
+ (
+ -v[1],
+ sqrtf
+ (
+ v[0]*v[0] + v[2]*v[2]
+ )
+ ) * C + k;
+
+ angles[0] = yaw;
+ angles[1] = pitch;
+}
+
+VG_STATIC void player_camera_portal_correction( player_instance *player )
+{
+ if( player->gate_waiting )
+ {
+ /* construct plane equation for reciever gate */
+ v4f plane;
+ v3_copy( player->gate_waiting->recv_to_world[2], plane );
+ plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
+
+ /* check camera polarity */
+ if( v3_dot( player->cam.pos, plane ) < plane[3] )
+ {
+ vg_success( "Plane cleared\n" );
+ player_apply_transport_to_cam( player->gate_waiting->transport );
+ player->gate_waiting = NULL;
+ }
+ else
+ {
+ /* de-transform camera and player back */
+ m4x3f inverse;
+ m4x3_invert_affine( player->gate_waiting->transport, inverse );
+ m4x3_mulv( inverse, player->cam.pos, player->cam.pos );
+
+ /* TODO: Find robust method for this */
+ v3f fwd_dir = { cosf(player->cam.angles[0]),
+ 0.0f,
+ sinf(player->cam.angles[0])};
+ m3x3_mulv( inverse, fwd_dir, fwd_dir );
+ player->cam.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
+
+ struct skeleton *sk = &player->playeravatar->sk;
+ skeleton_apply_transform( sk, inverse );
+ }
+ }
+}
+
+VG_STATIC void player__cam_iterate( player_instance *player )
+{
+ struct player_avatar *av = player->playeravatar;
+
+ v3_lerp( player->follow_pos, player->follow_pos_target,
+ vg.frame_delta * 15.0f, player->follow_pos );
+ camera_lerp_angles( player->follow_angles, player->follow_angles_target,
+ vg.frame_delta * 18.0f, player->follow_angles );
+
+ /* Blending */
+ player->camera_type_blend =
+ vg_lerpf( player->camera_type_blend,
+ (player->camera_mode == k_cam_firstperson)? 1.0f: 0.0f,
+ 5.0f * vg.frame_delta );
+ float t = player->camera_type_blend;
+
+ v3f p0, p1, a0, a1;
+ v3_lerp( player->follow_pos, player->override_pos,
+ player->cam_position_override_strength, p1 );
+ camera_lerp_angles( player->follow_angles, player->override_angles,
+ player->cam_angles_override_strength, a1 );
+
+ v3_copy( player->fpv_pos, p0 );
+ v3_copy( player->fpv_angles, a0 );
+
+ v3_lerp( p0, p1, player->camera_type_blend, player->cam.pos );
+ camera_lerp_angles( a0, a1, player->camera_type_blend, player->cam.angles );
+
+ /* FIXME: cl_fov */
+ player->cam.fov = vg_lerpf( 118.0f, 90.0f, player->camera_type_blend );
+
+ /* portal transitions */
+ player_camera_portal_correction( player );
+}
+
+VG_STATIC void player_set_follower_subject( player_instance *player,
+ v3f subj )
+{
+ v3f dir;
+ v3_sub( subj, player->follow_pos, dir );
+
+ if( v3_length2( dir ) < 0.1f*0.1f )
+ v3_copy( (v3f){ 0.0f, 0.0f, 1.0f }, dir ); /* FIXME */
+ else
+ v3_normalize( dir );
+
+ dir[1] *= 0.0f;
+
+ v3_muladds( subj, dir, -2.0f, player->follow_pos_target );
+ player_vector_angles( player->follow_angles_target, dir, 1.0f, 0.2f );
+}
+
+VG_STATIC void player_look( player_instance *player, v3f angles )
{
angles[2] = 0.0f;
v2_muladds( angles, vg.mouse_delta, 0.0025f, angles );
#include "player_api.h"
-void player_look( player_instance *player, v3f angles );
+VG_STATIC void player_look( player_instance *player, v3f angles );
+VG_STATIC void player__cam_iterate( player_instance *player );
+VG_STATIC void player_vector_angles( v3f angles, v3f v, float C, float k );
#endif /* PLAYER_COMMON_H */
m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
/*camera */
- m4x3_mulv( gate->transport, s->state.posl, s->state.posl );
m3x3_mulv( gate->transport, s->state.vl, s->state.vl );
- m3x3_mulv( gate->transport, s->state.dirl, s->state.dirl );
#if 0
mixedcam_transport( &s->state.cam, gate );
/* transform */
rb_extrapolate( &player->rb, dest->root_co, dest->root_q );
-
v3_muladds( dest->root_co, player->rb.to_world[1], -0.28f, dest->root_co );
v4f qresy, qresx, qresidual;
}
}
-VG_STATIC void skate_camera_vector_look( v3f angles, v3f v, float C, float k )
-{
- float yaw = atan2f( v[0], -v[2] ),
- pitch = atan2f
- (
- -v[1],
- sqrtf
- (
- v[0]*v[0] + v[2]*v[2]
- )
- ) * C + k;
-
- angles[0] = yaw;
- angles[1] = pitch;
-}
-
VG_STATIC void skate_camera_firstperson( player_instance *player )
{
struct player_skate *s = &player->_skate;
/* FIXME: viewpoint entity */
v3f vp = {-0.1f,1.8f,0.0f};
- m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, player->cam1.co );
- v3_zero( player->cam1.angles );
+ m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, player->fpv_pos );
+ v3_zero( player->fpv_angles );
v3f flat_dir,
vel_dir,
v3_lerp( flat_dir, vel_dir, vg_clampf( tti / 2.0f, 0.4f, 1.0f ), look_dir );
v3_lerp( s->state.vl, look_dir, 4.0f*vg.time_delta, s->state.vl );
-
- skate_camera_vector_look( player->cam1.angles, s->state.vl, 1.0f, 0.25f );
+ player_vector_angles( player->fpv_angles, s->state.vl, 1.0f, 0.25f );
}
VG_STATIC void skate_camera_thirdperson( player_instance *player )
v3f origin, dir, target;
v3_copy( player->rb.co, origin );
v3_add( origin, (v3f){0.0f,1.35f,0.0f}, origin );
- v3_sub( origin, s->state.posl, dir );
-
- if( v3_length2( dir ) < 0.1f*0.1f )
- v3_copy( (v3f){ 0.0f, 0.0f, 1.0f }, dir ); /* FIXME */
- else
- v3_normalize( dir );
-
- if( s->state.activity == k_skate_activity_air )
- dir[1] *= vg_maxf( 0.0f, 1.0f - (s->land_dist/2.0f) );
- dir[1] *= 0.0f;
-
- v3_muladds( origin, dir, -2.0f, target );
-
- v3_lerp( s->state.posl, target, vg.frame_delta * 15.0f, s->state.posl );
- v3_lerp( s->state.dirl, dir, 18.0f*vg.time_delta, s->state.dirl );
-
- v3_copy( s->state.posl, player->cam3.co );
- skate_camera_vector_look( player->cam3.angles, s->state.dirl, 1.0f, 0.2f );
+ player_set_follower_subject( player, origin );
}
VG_STATIC void player__skate_post_animate( player_instance *player )
struct player_skate *s = &player->_skate;
struct player_avatar *av = player->playeravatar;
- v3_zero( player->cam1.co );
- v3_zero( player->cam1.angles );
-
skate_camera_thirdperson( player );
skate_camera_firstperson( player );
+ player->cam_angles_override_strength = 0.0f;
+ player->cam_position_override_strength = 0.0f;
+
+
+
/* FIXME: Organize this. Its int wrong fucking place */
v3f vp0 = {0.0f,0.1f, 0.6f},
}
VG_STATIC void player__skate_transition( player_instance *player,
- v3f init_velocity )
+ v3f init_velocity,
+ enum skate_activity init_acitivity )
{
struct player_skate *s = &player->_skate;
s->state.activity_prev = k_skate_activity_ground;
- s->state.activity = k_skate_activity_air;
+ s->state.activity = init_acitivity;
v3f dir;
v3_copy( init_velocity, dir );
v3_normalize( dir );
+
+ vg_info( "init velocity: %f %f %f\n", init_velocity[0],
+ init_velocity[1],
+ init_velocity[2] );
q_axis_angle( player->rb.q, (v3f){0.0f,1.0f,0.0f},
atan2f( dir[0], dir[2] ) );
- v3_copy( player->cam.pos, s->state.posl );
-
- m3x3f temp;
- euler_m3x3( player->cam.angles, temp );
- v3_muls( temp[2], -1.0f, s->state.dirl );
v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
v3_copy( init_velocity, s->state.cog_v );
+ v3_copy( init_velocity, s->state.vl );
v3_copy( init_velocity, player->rb.v );
rb_update_transform( &player->rb );
-}
+ if( init_acitivity == k_skate_activity_air )
+ {
+ player_approximate_best_trajectory( player );
+ s->blend_fly = 1.0f;
+ }
+ else
+ s->blend_fly = 0.0f;
+
+ s->blend_slide = 0.0f;
+ s->blend_z = 0.0f;
+ s->blend_x = 0.0f;
+ s->blend_stand = 0.0f;
+ s->blend_push = 0.0f;
+ s->blend_jump = 0.0f;
+ s->blend_airdir = 0.0f;
+}
#endif /* PLAYER_SKATE_C */
v3f prev_pos;
/* FIXME: Sensible names */
+
+ v3f vl;
+#if 0
v3f vl, /* 1st */
posl, dirl; /* 3rd */
+#endif
}
state,
state_gate_storage;
struct respawn_point *rp );
VG_STATIC void player__skate_transition ( player_instance *player,
- v3f init_velocity );
+ v3f init_velocity,
+ enum skate_activity init_acitivity
+ );
#endif /* PLAYER_SKATE_H */
#include "player.h"
+VG_STATIC void player_walk_transfer_to_skate( player_instance *player,
+ enum skate_activity init )
+{
+ struct player_walk *w = &player->_walk;
+
+ v3f xy_speed, v;
+
+ v3_copy( player->rb.v, xy_speed );
+ xy_speed[1] = 0.0f;
+
+ if( v3_length2( xy_speed ) < 0.1f * 0.1f )
+ {
+ v[0] = -sinf( -w->state.angles[0] );
+ v[1] = 0.0f;
+ v[2] = -cosf( -w->state.angles[0] );
+ v3_muls( v, 1.6f, v );
+ }
+ else
+ v3_copy( player->rb.v, v );
+
+ player->subsystem = k_player_subsystem_skate;
+ player__skate_transition( player, v, init );
+ return;
+}
+
VG_STATIC void player__walk_pre_update( player_instance *player )
{
struct player_walk *w = &player->_walk;
player_look( player, w->state.angles );
- if( vg_input_button_down( player->input_use ) )
+ if( w->state.outro_anim )
{
- v3f xy_speed, v;
- v3_copy( player->rb.v, v );
- v3_copy( v, xy_speed );
- xy_speed[1] = 0.0f;
+ float outro_length = (float)w->state.outro_anim->length /
+ w->state.outro_anim->rate,
+ outro_time = vg.time - w->state.outro_start_time;
- if( v3_length2( xy_speed ) < 0.1f * 0.1f )
+ if( outro_time >= outro_length )
{
- v[0] = -sinf( -w->state.angles[0] );
- v[1] = 0.0f;
- v[2] = -cosf( -w->state.angles[0] );
- v3_muls( v, 1.6f, v );
+ w->state.outro_anim = NULL;
+ player_walk_transfer_to_skate( player, k_skate_activity_air );
+ return;
+ }
+ }
+ else if( vg_input_button_down( player->input_use ) )
+ {
+ if( w->state.activity == k_walk_activity_ground )
+ {
+ player_walk_transfer_to_skate( player, k_skate_activity_ground );
+ }
+ else
+ {
+ w->state.outro_anim = w->anim_jump_to_air;
+ w->state.outro_start_time = vg.time;
+ v3_copy( player->cam.pos, player->follow_pos );
+ v3_copy( player->cam.angles, player->follow_angles );
+ return;
}
-
- player->subsystem = k_player_subsystem_skate;
- player__skate_transition( player, v );
- return;
}
}
rb_prepare_contact( ct );
}
-
/*
* Move & Friction
float substep = vg_clampf( vg.accumulator / k_rb_delta, 0.0f, 1.0f );
v3_muladds( mtx[3], player->rb.v, k_rb_delta*substep, mtx[3] );
debug_capsule( mtx, w->collider.radius, w->collider.height, VG__YELOW );
+
+
+ /* Calculate header */
+ v3f xy_speed, v;
+
+ v3_copy( player->rb.v, xy_speed );
+ xy_speed[1] = 0.0f;
+
+ if( v3_length2( xy_speed ) > 0.1f * 0.1f )
+ w->state.heading_angle = atan2f( player->rb.v[0], player->rb.v[2] );
}
VG_STATIC void player__walk_animate( player_instance *player,
/* air */
skeleton_sample_anim( sk, w->anim_jump, vg.time*0.6f, bpose );
- skeleton_lerp_pose( sk, apose, bpose, w->blend_fly, dest->pose );
+ skeleton_lerp_pose( sk, apose, bpose, w->blend_fly, apose );
/* Create transform */
rb_extrapolate( &player->rb, dest->root_co, dest->root_q );
- q_axis_angle( dest->root_q, (v3f){0.0f,1.0f,0.0f},
- -w->state.angles[0]-VG_PIf*0.5f );
+
+ float walk_yaw = w->state.heading_angle + VG_PIf*0.5f;
+
+ if( w->state.outro_anim )
+ {
+ float outro_length = (float)w->state.outro_anim->length /
+ w->state.outro_anim->rate,
+ outro_time = vg.time - w->state.outro_start_time,
+ outro_t = outro_time / outro_length;
+
+ walk_yaw += -VG_PIf*0.5f*outro_t;
+
+ /* TODO: Compression */
+ v3_muladds( dest->root_co, player->rb.to_world[1],
+ -0.28f * outro_t, dest->root_co );
+
+ skeleton_sample_anim_clamped( sk, w->state.outro_anim,
+ outro_time, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, outro_t * 10.0f, dest->pose );
+ }
+ else
+ {
+ skeleton_copy_pose( sk, apose, dest->pose );
+ }
+
+ q_axis_angle( dest->root_q, (v3f){0.0f,1.0f,0.0f}, walk_yaw );
}
VG_STATIC void player__walk_post_animate( player_instance *player )
v3_add( player->rb.co, (v3f){0.0f,2.0f,0.0f}, origin );
- v3_muladds( origin, angles[2], 2.0f, player->cam3.co );
- v3_muladds( player->cam3.co, angles[0], 0.5f, player->cam3.co );
+ v3_muladds( origin, angles[2], 2.0f, player->override_pos );
+ v3_muladds( player->override_pos, angles[0], 0.5f, player->override_pos );
float t;
v3f n;
- if( spherecast_world( origin, player->cam3.co, 0.1f, &t, n ) != -1 )
- v3_lerp( origin, player->cam3.co, t, player->cam3.co );
- v3_copy( w->state.angles, player->cam3.angles );
+ if( spherecast_world( origin, player->override_pos, 0.1f, &t, n ) != -1 )
+ v3_lerp( origin, player->override_pos, t, player->override_pos );
+ v3_copy( w->state.angles, player->override_angles );
/* 1ST */
/* FIXME: viewpoint entity */
v3f vp = {-0.1f,1.8f,0.0f};
- m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, player->cam1.co );
- v3_copy( w->state.angles, player->cam1.angles );
+ m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, player->fpv_pos );
+ v3_copy( w->state.angles, player->fpv_angles );
/* FIXME: Organize this. Its int wrong fucking place */
v3f vp0 = {0.0f,0.1f, 0.6f},
vp1 = {0.0f,0.1f,-0.6f};
+ if( w->state.outro_anim )
+ {
+ float outro_length = (float)w->state.outro_anim->length /
+ w->state.outro_anim->rate,
+ outro_time = vg.time - w->state.outro_start_time,
+ outro_t = outro_time / outro_length;
+
+ /* FIXME: Compression */
+ v3_add( player->rb.co, (v3f){0.0f,1.35f,0.0f}, origin );
+ player_set_follower_subject( player, origin );
+
+ player->cam_angles_override_strength = 1.0f-outro_t;
+ player->cam_position_override_strength = 1.0f-outro_t;
+
+
+ v3f fpv_angles;
+ player_vector_angles( fpv_angles, player->rb.v, 1.0f, 0.25f );
+ v3_lerp( player->fpv_angles,fpv_angles, outro_t, player->fpv_angles );
+ }
+ else
+ {
+ player->cam_angles_override_strength = 1.0f;
+ player->cam_position_override_strength = 1.0f;
+ }
+
m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp0, TEMP_BOARD_0 );
m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp1, TEMP_BOARD_1 );
}
VG_STATIC void player__walk_im_gui( player_instance *player )
{
+ struct player_walk *w = &player->_walk;
player__debugtext( 1, "V: %5.2f %5.2f %5.2f",player->rb.v[0],
player->rb.v[1],
player->rb.v[2] );
player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",player->rb.co[0],
player->rb.co[1],
player->rb.co[2] );
+ player__debugtext( 1, "activity: %s\n",
+ (const char *[]){ "k_walk_activity_air",
+ "k_walk_activity_ground",
+ "k_walk_activity_sleep" }
+ [w->state.activity] );
+
+ if( w->state.outro_anim )
+ {
+ float outro_length = (float)w->state.outro_anim->length /
+ w->state.outro_anim->rate,
+ outro_time = vg.time - w->state.outro_start_time;
+ player__debugtext( 1, "outro time: %f / %f", outro_time, outro_length );
+ }
}
VG_STATIC void player__walk_bind( player_instance *player )
struct player_avatar *av = player->playeravatar;
struct skeleton *sk = &av->sk;
- w->anim_idle = skeleton_get_anim( sk, "idle_cycle" );
- w->anim_walk = skeleton_get_anim( sk, "walk" );
- w->anim_run = skeleton_get_anim( sk, "run" );
- w->anim_jump = skeleton_get_anim( sk, "jump" );
+ w->anim_idle = skeleton_get_anim( sk, "idle_cycle" );
+ w->anim_walk = skeleton_get_anim( sk, "walk" );
+ w->anim_run = skeleton_get_anim( sk, "run" );
+ w->anim_jump = skeleton_get_anim( sk, "jump" );
+ w->anim_jump_to_air = skeleton_get_anim( sk, "jump_to_air" );
}
VG_STATIC void player__walk_transition( player_instance *player, v3f angles )
struct
{
v3f angles;
+ float heading_angle;
+
v3f prev_pos;
enum walk_activity
k_walk_activity_sleep
}
activity;
+
+ struct skeleton_anim *outro_anim;
+ double outro_start_time;
}
state,
state_gate_storage;
enum mdl_surface_prop surface;
- struct skeleton_anim *anim_walk, *anim_run, *anim_idle, *anim_jump;
+ struct skeleton_anim *anim_walk, *anim_run, *anim_idle, *anim_jump,
+ *anim_jump_to_air;
float blend_fly,
blend_run,
return 0;
}
-VG_STATIC void keyframe_copy_pose( mdl_keyframe *kfa, mdl_keyframe *kfb, int num )
+VG_STATIC void keyframe_copy_pose( mdl_keyframe *kfa, mdl_keyframe *kfb,
+ int num )
{
for( int i=0; i<num; i++ )
kfb[i] = kfa[i];
/*
* Lerp between two sets of keyframes and store in dest. Rotations use Nlerp.
*/
-VG_STATIC void keyframe_lerp_pose( mdl_keyframe *kfa, mdl_keyframe *kfb, float t,
- mdl_keyframe *kfd, int count )
+VG_STATIC void keyframe_lerp_pose( mdl_keyframe *kfa, mdl_keyframe *kfb,
+ float t, mdl_keyframe *kfd, int count )
{
if( t <= 0.01f )
{
keyframe_lerp_pose( kfa, kfb, t, kfd, skele->bone_count-1 );
}
+VG_STATIC void skeleton_copy_pose( struct skeleton *skele,
+ mdl_keyframe *kfa, mdl_keyframe *kfd )
+{
+ keyframe_copy_pose( kfa, kfd, skele->bone_count-1 );
+}
+
/*
* Sample animation between 2 closest frames using time value. Output is a
* keyframe buffer that is allocated with an appropriate size
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff