#include "camera.h"
#include "player_model.h"
+VG_STATIC int localplayer_cmd_respawn( int argc, const char *argv[] )
+{
+ ent_spawn *rp = NULL, *r;
+ world_instance *world = localplayer.viewable_world;
+
+ if( argc == 1 ){
+ rp = world_find_spawn_by_name( world, argv[0] );
+ }
+ else if( argc == 0 ){
+ rp = world_find_closest_spawn( world, localplayer.rb.co );
+ }
+
+ if( !rp )
+ return 0;
+
+ player__spawn( &localplayer, rp );
+ return 1;
+}
+
+VG_STATIC void player_init(void)
+{
+ for( u32 i=0; i<vg_list_size(_player_system_register); i++ ){
+ if( _player_system_register[i] )
+ _player_system_register[i]();
+ }
+
+ vg_console_reg_cmd( "respawn", localplayer_cmd_respawn, NULL );
+}
+
PLAYER_API
void player__debugtext( int size, const char *fmt, ... )
{
inst->input_use = vg_create_named_input( "use", k_input_type_button );
inst->input_reset= vg_create_named_input( "reset", k_input_type_button );
inst->input_camera=vg_create_named_input( "camera", k_input_type_button );
+ inst->input_trick0=vg_create_named_input( "trick0", k_input_type_button );
+ inst->input_trick1=vg_create_named_input( "trick1", k_input_type_button );
+ inst->input_trick2=vg_create_named_input( "trick2", k_input_type_button );
const char *default_cfg[] =
{
"bind jump space",
"bind jump gp-a",
+ "bind trick0 mouse1",
+ "bind trick0 gp-a",
+ "bind trick1 mouse2",
+ "bind trick1 gp-b",
+ "bind trick2 gp-x", /* keyboard: m0 + m1 */
+
"bind push gp-b",
"bind push w",
"bind use gp-y",
"bind use e",
- "bind camera c"
+ "bind camera c",
+ "bind camera gp-rb"
};
for( int i=0; i<vg_list_size(default_cfg); i++ )
q_identity( inst->rb.q );
m4x3_identity( inst->rb.to_world );
m4x3_identity( inst->rb.to_local );
+
+ inst->rewind_length = 0;
+ inst->rewind_buffer =
+ vg_linear_alloc( vg_mem.rtmemory,
+ sizeof(struct rewind_frame) * PLAYER_REWIND_FRAMES );
+
}
/*
PLAYER_API
void player__bind( player_instance *player )
{
- player__skate_bind( player );
- player__walk_bind( player );
+ for( u32 i=0; i<vg_list_size(_player_bind); i++ ){
+ if( _player_bind[i] )
+ _player_bind[i]( player );
+ }
}
/*
* Gameloop events
* ----------------------------------------------------------------------------
*/
+
+VG_STATIC void player_save_rewind_frame( player_instance *player )
+{
+ if( player->rewind_length < PLAYER_REWIND_FRAMES ){
+ struct rewind_frame *fr =
+ &player->rewind_buffer[ player->rewind_length ++ ];
+
+ v2_copy( player->cam.angles, fr->ang );
+ v3_copy( player->cam.pos, fr->pos );
+
+ if( player->rewind_length >= 2 ){
+ player->rewind_total_length +=
+ v3_dist( player->rewind_buffer[player->rewind_length-1].pos,
+ player->rewind_buffer[player->rewind_length-2].pos );
+ }
+ }
+}
+
PLAYER_API
void player__pre_update( player_instance *player )
{
- if( vg_input_button_down( player->input_camera ) )
- {
+ if( player->rewinding ){
+ return;
+ }
+
+ if( vg_input_button_down( player->input_reset ) ){
+ double delta = world_global.time - world_global.last_use;
+
+ if( (delta <= RESET_MAX_TIME) && (world_global.last_use != 0.0) ){
+ player->rewinding = 1;
+ player->rewind_sound_wait = 1;
+ player->rewind_time = (double)player->rewind_length - 0.0001;
+ player_save_rewind_frame( player );
+
+ audio_lock();
+ audio_oneshot( &audio_rewind[0], 1.0f, 0.0f );
+ audio_unlock();
+
+ /* based on testing. DONT CHANGE!
+ *
+ * time taken: y = (x^(4/5)) * 74.5
+ * inverse : x = (2/149)^(4/5) * y^(4/5)
+ */
+
+ float constant = powf( 2.0f/149.0f, 4.0f/5.0f ),
+ curve = powf( player->rewind_total_length, 4.0f/5.0f );
+
+ player->rewind_predicted_time = constant * curve;
+ player->rewind_start = vg.time;
+ player->subsystem = player->subsystem_gate;
+ player->rb = player->rb_gate_storage;
+ v3_copy( player->angles_storage, player->angles );
+
+ if( _player_restore[ player->subsystem ] )
+ _player_restore[ player->subsystem ]( player );
+ }
+ else{
+ if( player->subsystem == k_player_subsystem_dead ){
+ localplayer_cmd_respawn( 0, NULL );
+ }
+ else{
+ /* cant do that */
+ audio_lock();
+ audio_oneshot( &audio_rewind[4], 1.0f, 0.0f );
+ audio_unlock();
+ }
+ }
+ }
+
+ if( vg_input_button_down( player->input_camera ) ){
if( player->camera_mode == k_cam_firstperson )
player->camera_mode = k_cam_thirdperson;
else
PLAYER_API
void player__update( player_instance *player )
{
+ if( player->rewinding )
+ return;
+
if( _player_update[ player->subsystem ] )
_player_update[ player->subsystem ]( player );
}
PLAYER_API
void player__post_update( player_instance *player )
{
+ if( player->rewinding )
+ return;
+
if( _player_post_update[ player->subsystem ] )
_player_post_update[ player->subsystem ]( player );
+
+ if((player->subsystem != k_player_subsystem_dead) && !player->gate_waiting){
+ player->rewind_accum += vg.frame_delta;
+
+ if( player->rewind_accum > 0.25f ){
+ player->rewind_accum -= 0.25f;
+ player_save_rewind_frame( player );
+ }
+ }
}
VG_STATIC void player_apply_transport_to_cam( m4x3f transport )
m4x3_expand( transport_i, transport_4 );
m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
m4x4_mul( main_camera.mtx.v, transport_4, main_camera.mtx.v );
+
+ /* we want the regular transform here no the inversion */
+ m4x3_expand( transport, transport_4 );
+ m4x4_mul( gate_camera.mtx.pv, transport_4, gate_camera.mtx.pv );
+ m4x4_mul( gate_camera.mtx.v, transport_4, gate_camera.mtx.v );
+}
+
+__attribute__ ((deprecated))
+VG_STATIC void gate_rotate_angles( ent_gate *gate, v3f angles, v3f d )
+{
+ v3_copy( angles, d );
+ return;
+
+ v3f fwd_dir = { cosf(angles[0]),
+ 0.0f,
+ sinf(angles[0])};
+ m3x3_mulv( gate->transport, fwd_dir, fwd_dir );
+
+ v3_copy( angles, d );
+ d[0] = atan2f( fwd_dir[2], fwd_dir[0] );
}
/*
* Applies gate transport to a player_interface
*/
PLAYER_API
-void player__pass_gate( player_instance *player, teleport_gate *gate )
+void player__pass_gate( player_instance *player, ent_gate *gate )
{
+ world_routes_fracture( get_active_world(), gate,
+ player->rb.co, player->rb.v );
+
player->gate_waiting = gate;
+ world_routes_activate_entry_gate( get_active_world(), gate );
- /* TODO: Add back other logic thats normally here */
-}
+ m4x3_mulv( gate->transport, player->tpv_lpf, player->tpv_lpf );
+ m3x3_mulv( gate->transport, player->cam_velocity_smooth,
+ player->cam_velocity_smooth );
-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 );
- }
- }
+ m3x3_copy( player->basis, player->basis_gate );
+
+ v4f q;
+ m3x3_q( gate->transport, q );
+ q_mul( q, player->qbasis, player->qbasis );
+ q_normalize( player->qbasis );
+ q_m3x3( player->qbasis, player->basis );
+ m3x3_transpose( player->basis, player->invbasis );
+
+ player->subsystem_gate = player->subsystem;
+ player->rb_gate_storage = player->rb;
+ v3_copy( player->angles, player->angles_storage );
+ player->rewind_length = 0;
+ player->rewind_total_length = 0.0f;
+ player->rewind_gate = gate;
+ player->rewind_accum = 0.0f;
+
+ m4x3_mulv( gate->transport, player->cam.pos, player->cam.pos );
+ player_save_rewind_frame( player );
+
+ if( gate->type == k_gate_type_nonlocel )
+ world_global.active_world = gate->target;
+
+ world_global.in_volume = 0;
+
+ audio_lock();
+ audio_oneshot( &audio_gate_pass, 1.0f, 0.0f );
+ audio_unlock();
}
VG_STATIC void player__pre_render( player_instance *player )
{
- if( _player_animate[ player->subsystem ] )
- {
+ if( _player_animate[ player->subsystem ] ){
player_animation res;
_player_animate[ player->subsystem ]( player, &res );
- /* TODO: eventually, blending code goes here */
-
m4x3f transform;
q_m3x3( res.root_q, transform );
v3_copy( res.root_co, transform[3] );
struct skeleton *sk = &player->playeravatar->sk;
+ if( player->holdout_time > 0.0f ){
+ skeleton_lerp_pose( sk, res.pose, player->holdout_pose,
+ player->holdout_time, res.pose );
+ player->holdout_time -= vg.frame_delta * 2.0f;
+ }
+
skeleton_apply_pose( sk, res.pose, k_anim_apply_defer_ik );
skeleton_apply_ik_pass( sk );
skeleton_apply_pose( sk, res.pose, k_anim_apply_deffered_only );
skeleton_apply_inverses( sk );
skeleton_apply_transform( sk, transform );
+
skeleton_debug( sk );
}
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 );
+ struct player_avatar *av = player->playeravatar;
+ v3f vp0 = {0.0f,0.1f, 0.55f},
+ vp1 = {0.0f,0.1f,-0.55f};
+
+ struct ub_world_lighting *ubo = &get_active_world()->ub_lighting;
+ m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp0, ubo->g_board_0 );
+ m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp1, ubo->g_board_1 );
+
+ if( player->rewinding ){
+ if( player->rewind_time <= 0.0f ){
+ double taken = vg.time - player->rewind_start;
+ vg_success( "Rewind took (rt, pt, tl): %f, %f, %f\n",
+ taken, player->rewind_predicted_time,
+ player->rewind_total_length );
+
+ player->rewinding = 0;
+ player->rewind_length = 1;
+ player->rewind_total_length = 0.0f;
+ player->rewind_accum = 0.0f;
+ world_global.sky_target_rate = 1.0;
+ world_global.time = world_global.last_use;
+ }
+ else{
+ world_global.sky_target_rate = -100.0;
+
+ float budget = vg.time_delta,
+ overall_length = player->rewind_length;
+
+ for( int i=0; (i<10)&&(player->rewind_time>0.0f)&&(budget>0.0f); i++ ){
+ /* Interpolate frames */
+ int i0 = floorf( player->rewind_time ),
+ i1 = VG_MIN( i0+1, player->rewind_length-1 );
+
+ struct rewind_frame *fr = &player->rewind_buffer[i0],
+ *fr1 = &player->rewind_buffer[i1];
+
+ float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
+ subl = vg_fractf( player->rewind_time ) + 0.001f,
+
+ sramp = 3.0f-(1.0f/(0.4f+0.4f*player->rewind_time)),
+ speed = sramp*28.0f + 0.5f*player->rewind_time,
+ mod = speed * (budget / dist),
+
+ advl = vg_minf( mod, subl ),
+ advt = (advl / mod) * budget;
+
+ player->dist_accum += speed * advt;
+ player->rewind_time -= advl;
+ budget -= advt;
+ }
+
+ player->rewind_time = vg_maxf( 0.0f, player->rewind_time );
+
+ float current_time = vg.time - player->rewind_start,
+ remaining = player->rewind_predicted_time - current_time;
+
+ if( player->rewind_sound_wait ){
+ if( player->rewind_predicted_time >= 6.5f ){
+ if( remaining <= 6.5f ){
+ audio_lock();
+ audio_oneshot( &audio_rewind[3], 1.0f, 0.0f );
+ audio_unlock();
+ player->rewind_sound_wait = 0;
+ }
+ }
+ else if( player->rewind_predicted_time >= 2.5f ){
+ if( remaining <= 2.5f ){
+ audio_lock();
+ audio_oneshot( &audio_rewind[2], 1.0f, 0.0f );
+ audio_unlock();
+ player->rewind_sound_wait = 0;
+ }
+ }
+ else if( player->rewind_predicted_time >= 1.5f ){
+ if( remaining <= 1.5f ){
+ audio_lock();
+ audio_oneshot( &audio_rewind[1], 1.0f, 0.0f );
+ audio_unlock();
+ player->rewind_sound_wait = 0;
+ }
+ }
+ }
+
+ int i0 = floorf( player->rewind_time ),
+ i1 = VG_MIN( i0+1, player->rewind_length-1 );
+
+ struct rewind_frame *fr = &player->rewind_buffer[i0],
+ *fr1 = &player->rewind_buffer[i1];
+
+ float sub = vg_fractf(player->rewind_time);
+
+ v3_lerp( fr->pos, fr1->pos, sub, player->cam_override_pos );
+ player->cam_override_angles[0] =
+ vg_alerpf( fr->ang[0], fr1->ang[0], sub );
+ player->cam_override_angles[1] =
+ vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
+
+ float blend = player->rewind_time * 0.25f;
+ player->cam_override_strength = vg_clampf( blend, 0.0f, 1.0f );
+ }
+ }
+ else player->cam_override_strength = 0.0f;
- player_camera_portal_correction( player );
+ player__cam_iterate( player );
}
PLAYER_API void player__render( camera *cam, player_instance *player )
{
- shader_viewchar_use();
+ shader_model_character_view_use();
vg_tex2d_bind( player->playertex, 0 );
- shader_viewchar_uTexMain( 0 );
- shader_viewchar_uCamera( cam->transform[3] );
- shader_viewchar_uPv( cam->mtx.pv );
- shader_link_standard_ub( _shader_viewchar.id, 2 );
- glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
+ shader_model_character_view_uTexMain( 0 );
+ shader_model_character_view_uCamera( cam->transform[3] );
+ shader_model_character_view_uPv( cam->mtx.pv );
+ shader_model_character_view_uTexSceneDepth( 1 );
+ render_fb_bind_texture( gpipeline.fb_main, 2, 1 );
+ v3f inverse;
+ render_fb_inverse_ratio( gpipeline.fb_main, inverse );
+ inverse[2] = main_camera.farz-main_camera.nearz;
+
+ shader_model_character_view_uInverseRatioDepth( inverse );
+ render_fb_inverse_ratio( NULL, inverse );
+ inverse[2] = cam->farz-cam->nearz;
+ shader_model_character_view_uInverseRatioMain( inverse );
+
+ world_instance *world = get_active_world();
+ world_link_lighting_ub( world, _shader_model_character_view.id );
+ world_bind_position_texture( world, _shader_model_character_view.id,
+ _uniform_model_character_view_g_world_depth, 2 );
+ world_bind_light_array( world, _shader_model_character_view.id,
+ _uniform_model_character_view_uLightsArray, 3 );
+ world_bind_light_index( world, _shader_model_character_view.id,
+ _uniform_model_character_view_uLightsIndex, 4 );
+
+ glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms,
player->playeravatar->sk.bone_count,
0,
(float *)player->playeravatar->sk.final_mtx );
vg_uictx.cursor[0] = vg.window_x;
+ player__debugtext( 1, "angles: " PRINTF_v3f( player->cam.angles ) );
+ player__debugtext( 1, "basis: " PRINTF_v4f( player->qbasis ) );
+
if( _player_im_gui[ player->subsystem ] )
_player_im_gui[ player->subsystem ]( player );
}
PLAYER_API void player__spawn( player_instance *player,
- struct respawn_point *rp )
+ ent_spawn *rp )
{
- v3_copy( rp->co, player->rb.co );
+ v3_copy( rp->transform.co, player->rb.co );
v3_zero( player->rb.v );
v3_zero( player->rb.w );
q_identity( player->rb.q );
rb_update_transform( &player->rb );
+ q_identity( player->qbasis );
+ m3x3_identity( player->basis );
+ m3x3_identity( player->invbasis );
+
+ player->subsystem = k_player_subsystem_walk;
+ player->gate_waiting = NULL;
+
if( _player_reset[ player->subsystem ] )
_player_reset[ player->subsystem ]( player, rp );
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff