#define PLAYER_DEVICE_WALK_H
#include "player_interface.h"
+#include "player_device_common.h"
+#include "skeleton.h"
+#include "player_model.h"
-VG_STATIC float
- k_walkspeed = 10.0f,
- k_airspeed = 2.0f,
- k_stopspeed = 4.0f,
- k_walk_accel = 10.0f,
- k_walk_air_accel = 7.0f,
- k_walk_friction = 10.0f,
- k_walk_step_height = 0.2f;
-
+VG_STATIC
struct player_device_walk
{
rb_capsule collider;
struct
{
v3f angles;
+ v3f prev_pos;
enum walk_activity
{
}
activity;
}
- state;
+ state,
+ state_gate_storage;
enum mdl_surface_prop surface;
-};
+ struct skeleton_anim *anim_walk, *anim_run, *anim_idle, *anim_jump;
+
+ float blend_fly,
+ blend_run,
+ blend_walk,
+
+ move_speed,
+ walk_timer;
-VG_STATIC void player_walk_pre_update( player_interface *player,
- player_attachment *at )
+ u32 device_id_skate;
+}
+localplayer_device_walk;
+
+VG_STATIC void player_walk_pre_update( player_device *dev,
+ player_interface *player )
{
- struct player_device_walk *w = at->storage;
+ struct player_device_walk *w = dev->storage;
player_look( player, w->state.angles );
+ if( vg_input_button_down( player->input_use ) )
+ {
+ struct device_transition_skateboard inf;
+
+ v3f xy_speed;
+ v3_copy( player->rb.v, xy_speed );
+ xy_speed[1] = 0.0f;
+
+ if( v3_length2( xy_speed ) > 0.1f * 0.1f )
+ {
+ v3_copy( player->rb.v, inf.dir );
+ }
+ else
+ {
+ inf.dir[0] = -sinf( -w->state.angles[0] );
+ inf.dir[1] = 0.0f;
+ inf.dir[2] = -cosf( -w->state.angles[0] );
+ v3_muls( inf.dir, 1.6f, player->rb.v );
+ }
+
+ player_transition_to_device( player, w->device_id_skate, &inf );
+ return;
+ }
+
#if 0
v3f walk = { player->input_walkh->axis.value,
0.0f,
v3_muls( v, newspeed, v );
}
-VG_STATIC void player_walk_update( player_interface *player,
- player_attachment *at )
+VG_STATIC void player_walk_update( player_device *dev,
+ player_interface *player )
{
- struct player_device_walk *w = at->storage;
+ struct player_device_walk *w = dev->storage;
+ v3_copy( player->rb.co, w->state.prev_pos );
+
w->collider.height = 2.0f;
w->collider.radius = 0.3f;
if( v2_length2(walk) > 0.001f )
v2_normalize_clamp( walk );
+ w->move_speed = v2_length( walk );
+
/*
* Collision detection
*/
if( v2_length2(walk) > 0.001f )
{
- vg_info( "%f %f\n", walk[0], walk[1] );
player_accelerate( player->rb.v, movedir, nominal_speed, accel_speed );
v3_normalize( movedir );
}
v3_add( player->rb.co, (v3f){0.0f, 1.0f, 0.0f}, mtx[3] );
debug_capsule( mtx, w->collider.radius, w->collider.height, VG__GREEN );
+
+ /*
+ * CCD routine
+ * ---------------------------------------------------
+ *
+ */
+ v3f lwr_prev,
+ lwr_now,
+ lwr_offs = { 0.0f, w->collider.radius, 0.0f };
+
+ v3_add( lwr_offs, w->state.prev_pos, lwr_prev );
+ v3_add( lwr_offs, player->rb.co, lwr_now );
+
+ v3f movedelta;
+ v3_sub( player->rb.co, w->state.prev_pos, movedelta );
+
+ float movedist = v3_length( movedelta );
+
+ if( movedist > 0.3f )
+ {
+ float t, sr = w->collider.radius-0.04f;
+ v3f n;
+
+ if( spherecast_world( lwr_prev, lwr_now, sr, &t, n ) != -1 )
+ {
+ v3_lerp( lwr_prev, lwr_now, vg_maxf(0.01f,t), player->rb.co );
+ player->rb.co[1] -= w->collider.radius;
+ rb_update_transform( &player->rb );
+
+ v3_add( player->rb.co, (v3f){0.0f, 1.0f, 0.0f}, mtx[3] );
+ debug_capsule( mtx, w->collider.radius, w->collider.height, VG__RED );
+ }
+ }
+
+ teleport_gate *gate;
+ if( (gate = world_intersect_gates( player->rb.co, w->state.prev_pos )) )
+ {
+ struct player_device_walk *w = dev->storage;
+
+ m4x3_mulv( gate->transport, player->rb.co, player->rb.co );
+ m3x3_mulv( gate->transport, player->rb.v, player->rb.v );
+ rb_update_transform( &player->rb );
+
+ /* analytical rotation of yaw */
+ v3f fwd_dir = { cosf(w->state.angles[0]),
+ 0.0f,
+ sinf(w->state.angles[0])};
+ m3x3_mulv( gate->transport, fwd_dir, fwd_dir );
+ w->state.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
+
+ w->state_gate_storage = w->state;
+ player_pass_gate( player, gate );
+ }
}
-VG_STATIC void player_walk_post_update( player_interface *player,
- player_attachment *at )
+VG_STATIC void player_walk_post_update( player_device *dev,
+ player_interface *player )
{
-
+ struct player_device_walk *w = dev->storage;
+
+ m4x3f mtx;
+ m3x3_identity( mtx );
+ v3_add( player->rb.co, (v3f){0.0f, 1.0f, 0.0f}, mtx[3] );
+
+ 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 );
+
+#if 0
+ player_apply_transport_to_cam( gate->transport );
+#endif
+
}
-VG_STATIC void player_walk_get_camera( player_interface *player,
- player_attachment *at, camera *cam )
+VG_STATIC void player_walk_animate( player_device *dev,
+ player_interface *player )
{
- struct player_device_walk *w = at->storage;
+ struct player_device_walk *w = dev->storage;
+ struct skeleton *sk = &player->playeravatar->sk;
- float substep = vg_clampf( vg.accumulator / k_rb_delta, 0.0f, 1.0f );
- v3f pos;
- v3_muladds( player->rb.co, player->rb.v, k_rb_delta*substep, pos );
+ {
+ float fly = (w->state.activity == k_walk_activity_air)? 1.0f: 0.0f,
+ rate;
- v3_add( pos, (v3f){0.0f,1.8f,0.0f}, cam->pos );
- v3_copy( w->state.angles, cam->angles );
- cam->fov = 90.0f;
+ if( w->state.activity == k_walk_activity_air )
+ rate = 2.4f;
+ else
+ rate = 9.0f;
+
+ w->blend_fly = vg_lerpf( w->blend_fly, fly, rate*vg.time_delta );
+ w->blend_run = vg_lerpf( w->blend_run,
+ w->move_speed *
+ (1.0f + player->input_walk->button.value*0.5f),
+ 2.0f*vg.time_delta );
+ }
+
+ player_pose apose, bpose;
+
+ if( w->move_speed > 0.025f )
+ {
+ /* TODO move */
+ float walk_norm = 30.0f/(float)w->anim_walk->length,
+ run_norm = 30.0f/(float)w->anim_run->length,
+ walk_adv = vg_lerpf( walk_norm, run_norm, w->move_speed );
+
+ w->walk_timer += walk_adv * vg.time_delta;
+ }
+ else
+ {
+ w->walk_timer = 0.0f;
+ }
+
+ float walk_norm = (float)w->anim_walk->length/30.0f,
+ run_norm = (float)w->anim_run->length/30.0f,
+ t = w->walk_timer,
+ l = vg_clampf( w->blend_run*15.0f, 0.0f, 1.0f ),
+ idle_walk = vg_clampf( (w->blend_run-0.1f)/(1.0f-0.1f), 0.0f, 1.0f );
+
+ /* walk/run */
+ skeleton_sample_anim( sk, w->anim_walk, t*walk_norm, apose );
+ skeleton_sample_anim( sk, w->anim_run, t*run_norm, bpose );
+
+ skeleton_lerp_pose( sk, apose, bpose, l, apose );
+
+ /* idle */
+ skeleton_sample_anim( sk, w->anim_idle, vg.time*0.1f, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, 1.0f-idle_walk, apose );
+
+ /* air */
+ skeleton_sample_anim( sk, w->anim_jump, vg.time*0.6f, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, w->blend_fly, dev->pose );
+
+ /* Create transform */
+ rb_extrapolate( &player->rb, dev->pose_root_co, dev->pose_root_q );
+ q_axis_angle( dev->pose_root_q, (v3f){0.0f,1.0f,0.0f},
+ -w->state.angles[0]-VG_PIf*0.5f );
+}
+
+VG_STATIC void player_walk_post_animate( player_device *dev,
+ player_interface *player )
+{
+ /*
+ * Camera
+ */
+ struct player_device_walk *w = dev->storage;
+ struct player_avatar *av = player->playeravatar;
+
+ /* 3RD */
+ m3x3f angles;
+ euler_m3x3( w->state.angles, angles );
+
+ v3f cast_dir, origin;
+
+ v3_add( player->rb.co, (v3f){0.0f,2.0f,0.0f}, origin );
+
+ v3_muladds( origin, angles[2], 2.0f, dev->cam_3rd.pos );
+ v3_muladds( dev->cam_3rd.pos, angles[0], 0.5f, dev->cam_3rd.pos );
+
+ float t;
+ v3f n;
+ if( spherecast_world( origin, dev->cam_3rd.pos, 0.1f, &t, n ) != -1 )
+ v3_lerp( origin, dev->cam_3rd.pos, t, dev->cam_3rd.pos );
+ v3_copy( w->state.angles, dev->cam_3rd.angles );
+ dev->cam_3rd.fov = 90.0f;
+
+
+ /* 1ST */
+ /* FIXME: viewpoint entity */
+ v3f vp = {-0.1f,1.8f,0.0f};
+ m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, dev->cam_1st.pos );
+ v3_copy( w->state.angles, dev->cam_1st.angles );
+ dev->cam_1st.fov = 90.0f;
+
+ /* FIXME: Organize this. Its int wrong fucking place */
+ v3f vp0 = {0.0f,0.1f, 0.6f},
+ vp1 = {0.0f,0.1f,-0.6f};
+
+ 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_ui( player_interface *player,
- player_attachment *at )
+
+VG_STATIC void player_walk_ui( player_device *dev, player_interface *player )
{
player_debugtext( 1, "V: %5.2f %5.2f %5.2f",player->rb.v[0],
player->rb.v[1],
player->rb.co[2] );
}
-player_device player_device_walk =
+VG_STATIC void player_walk_bind( player_device *dev, player_interface *player )
+{
+ struct player_device_walk *w = dev->storage;
+ 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->device_id_skate = player_get_device( player, "skateboard" );
+}
+
+VG_STATIC int player_walk_event( player_device *dev, player_interface *player,
+ enum player_device_event_type ev, void *data )
+{
+ struct player_device_walk *w = dev->storage;
+
+ if( ev == k_player_device_event_bind )
+ {
+ player_walk_bind( dev, player );
+ }
+ else if( ev == k_player_device_event_custom_transition )
+ {
+ struct device_transition_walk *inf = data;
+ v3_copy( inf->angles, w->state.angles );
+ }
+ else if( ev == k_player_device_event_pre_update )
+ {
+ player_walk_pre_update( dev, player );
+ }
+ else if( ev == k_player_device_event_update )
+ {
+ player_walk_update( dev, player );
+ }
+ else if( ev == k_player_device_event_post_update )
+ {
+ player_walk_post_update( dev, player );
+ }
+ else if( ev == k_player_device_event_animate )
+ {
+ player_walk_animate( dev, player );
+ }
+ else if( ev == k_player_device_event_post_animate )
+ {
+ player_walk_post_animate( dev, player );
+ }
+ else if( ev == k_player_device_event_debug_ui )
+ {
+ player_walk_ui( dev, player );
+ }
+ else
+ return 0;
+
+ return 1;
+}
+
+VG_STATIC player_device player_device_walk =
{
- .pre_update = player_walk_pre_update,
- .update = player_walk_update,
- .post_update = player_walk_post_update,
- .get_camera = player_walk_get_camera,
- .debug_ui = player_walk_ui
+ .name = "walk",
+ .event = player_walk_event,
+ .storage = &localplayer_device_walk
};
#endif /* PLAYER_DEVICE_WALK_H */
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff