refactor rewind tape 1

diff --git a/player.c b/player.c
index 25e4b774b8528627704c656378330addb42ef0a2..cb2a174ea4531005224ea4c33044e47324a9957d 100644 (file)
--- a/player.c
+++ b/player.c
@@ -113,18 +113,6 @@ void player__bind( player_instance *player )
 
 PLAYER_API
 void player__pre_update( player_instance *player ){
-   if( button_down( k_srbind_reset ) && !player->immobile ){
-      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( button_down( k_srbind_camera ) && !player->immobile ){
       if( player->cam_control.camera_mode == k_cam_firstperson )
          player->cam_control.camera_mode = k_cam_thirdperson;

diff --git a/player_render.c b/player_render.c
index 851b98fb34c2ef0dabf74ea67df68990a7b3ba7c..49a67c1ce2244eebe5e583888025900478c3fe36 100644 (file)
--- a/player_render.c
+++ b/player_render.c
@@ -7,6 +7,7 @@
 #include "player_model.h"
 #include "ent_skateshop.h"
 #include "audio.h"
+#include "input.h"
 
 #include "shaders/model_character_view.h"
 #include "shaders/model_board_view.h"
@@ -174,150 +175,109 @@ VG_STATIC void player_animate( player_instance *player ){
       _player_post_animate[ player->subsystem ]( player );
 }
 
-VG_STATIC void player__pre_render( player_instance *player ){
-   player->cam_override_strength = 0.0f;
-   player_animate( player );
+VG_STATIC void player_animate_from_replay( player_instance *player ){
+   /* TODO: frame blending */
 
-   /* dev playbacker */
-   if( k_replay_test ){
-      f64 speed = 1.0;
-      f64 target = player->replay.cursor;
+   player_animation res;
+   replay_frame *frame = player->replay.cursor_frame;
 
-      if( vg_getkey( SDLK_9 ) ){
-         target -= vg.time_frame_delta * speed;
-         player->replay.control = k_replay_control_scrub;
-         replay_seek( &player->replay, target );
-      }
-      if( vg_getkey( SDLK_0 ) ){
-         target += vg.time_frame_delta * speed;
-         player->replay.control = k_replay_control_scrub;
-         replay_seek( &player->replay, target );
-      }
+   if( frame ){
+      memcpy( &res, &frame->anim, sizeof(frame->anim) );
+      memcpy( &frame->board_pose, &player->board_pose, 
+              sizeof(player->board_pose) );
+      v3_copy( frame->cam_pos, player->cam_override_pos );
+      v3_copy( frame->cam_angles, player->cam_override_angles );
+      player->cam_override_fov = frame->cam_fov;
+      player->cam_override_strength = 1.0f;
+   }
+   else return;
 
-      if( vg_getkey( SDLK_7 ) )
-         player->replay.control = k_replay_control_play;
+   struct skeleton *sk = &player->playeravatar->sk;
+   skeleton_apply_pose( sk, res.pose, k_anim_apply_absolute );
+}
 
-      if( player->replay.control == k_replay_control_play ){
-         target += vg.time_frame_delta;
-         replay_seek( &player->replay, target );
-      }
+VG_STATIC void player_record_replay( player_instance *player, int force ){
+   /* replay recorder */
+   replay_buffer *replay = &player->replay;
 
-      if( vg_getkey( SDLK_8 ) ){
-         replay_frame *prev = replay_find_recent_stateframe( &player->replay );
-
-         if( prev ){
-            /* TODO: Make gamestate_apply function / swap ... */
-            replay_gamestate *gs = replay_frame_gamestate( prev, 0 );
-
-            if( gs->system == k_player_subsystem_walk ){
-               memcpy( &player->_walk.state, &gs->walk, 
-                        sizeof(struct player_walk_state) );
-            }
-            else if( gs->system == k_player_subsystem_skate ){
-               memcpy( &player->_skate.state, &gs->skate, 
-                        sizeof(struct player_skate_state) );
-            }
-            player->subsystem = gs->system;
-
-            memcpy( &player->rb, &gs->rb, sizeof(rigidbody) );
-            v3_copy( gs->angles, player->angles );
-            v3_copy( prev->cam_pos, player->cam.pos );
-            v3_copy( prev->cam_angles, player->cam_override_angles );
-            player->cam.fov = prev->cam_fov;
-            memcpy( &player->cam_control, &gs->cam_control, 
-                     sizeof(struct player_cam_controller) );
-
-            /* chop end off replay */
-            prev->r = NULL;
-            player->replay.statehead = prev;
-            player->replay.head = prev;
-            player->replay.cursor_frame = prev;
-            player->replay.cursor = prev->time;
-            vg.time = prev->time;
-
-            k_replay_test = 0;
-            player__pre_render( player );
-            return;
-         }
-      }
+   f64 delta      = 9999999.9,
+       statedelta = 9999999.9;
 
-      player_animation res;
-      replay_frame *frame = player->replay.cursor_frame;
-
-      if( frame ){
-         memcpy( &res, &frame->anim, sizeof(frame->anim) );
-         memcpy( &frame->board_pose, &player->board_pose, 
-                 sizeof(player->board_pose) );
-         v3_copy( frame->cam_pos, player->cam_override_pos );
-         v3_copy( frame->cam_angles, player->cam_override_angles );
-         player->cam_override_fov = frame->cam_fov;
-         player->cam_override_strength = 1.0f;
-      }
-      else return;
+   if( replay->head )
+      delta = vg.time - replay->head->time;
 
-      struct skeleton *sk = &player->playeravatar->sk;
-      skeleton_apply_pose( sk, res.pose, k_anim_apply_absolute );
-   }
-   else {
-      /* replay recorder */
-      replay_buffer *replay = &player->replay;
+   if( replay->statehead )
+      statedelta = vg.time - replay->statehead->time;
 
-      f64 delta      = 9999999.9,
-          statedelta = 9999999.9;
+   const f64 k_replay_rate = 1.0/30.0,
+             k_gamestate_rate = 0.5;
 
-      if( replay->head )
-         delta = vg.time - replay->head->time;
+   u16 gamestates = 0;
+   if( statedelta > k_gamestate_rate || force /* or switching */ ){
+      gamestates = 1;
+   }
+   
+   if( (delta > k_replay_rate) || gamestates ){
+      replay_frame *frame = replay_newframe( replay, gamestates, 0 );
+      replay->cursor = vg.time;
+      replay->cursor_frame = frame;
 
-      if( replay->statehead )
-         statedelta = vg.time - replay->statehead->time;
+      player_animation *res = &frame->anim;
+      v3_zero( res->root_co );
+      q_identity( res->root_q );
+      res->type = k_player_animation_type_absolute;
 
-      const f64 k_replay_rate = 1.0/30.0,
-                k_gamestate_rate = 0.5;
+      struct skeleton *sk = &player->playeravatar->sk;
+      skeleton_decompose_mtx_absolute( sk, res->pose );
+
+      memcpy( &frame->board_pose, &player->board_pose, 
+               sizeof(player->board_pose) );
+      frame->time = vg.time;
+      v3_copy( player->cam.pos, frame->cam_pos );
+      v3_copy( player->cam.angles, frame->cam_angles );
+      frame->cam_fov = player->cam.fov;
+
+      if( gamestates ){
+         replay_gamestate *gs = replay_frame_gamestate( frame, 0 );
+         gs->system = player->subsystem;
+
+         if( player->subsystem == k_player_subsystem_walk ){
+            memcpy( &gs->walk, &player->_walk.state, 
+                     sizeof(struct player_walk_state) );
+         }
+         else if( player->subsystem == k_player_subsystem_skate ){
+            memcpy( &gs->skate, &player->_skate.state, 
+                     sizeof(struct player_skate_state) );
+         }
 
-      u16 gamestates = 0;
-      if( statedelta > k_gamestate_rate /* or switching */ ){
-         gamestates = 1;
+         memcpy( &gs->rb, &player->rb, sizeof(rigidbody) );
+         memcpy( &gs->cam_control, &player->cam_control, 
+                  sizeof(struct player_cam_controller) );
+         v3_copy( player->angles, gs->angles );
       }
-      
-      if( (delta > k_replay_rate) || gamestates ){
-         replay_frame *frame = replay_newframe( replay, gamestates, 0 );
-         replay->cursor = vg.time;
-         replay->cursor_frame = frame;
-
-         player_animation *res = &frame->anim;
-         v3_zero( res->root_co );
-         q_identity( res->root_q );
-         res->type = k_player_animation_type_absolute;
-
-         struct skeleton *sk = &player->playeravatar->sk;
-         skeleton_decompose_mtx_absolute( sk, res->pose );
-
-         memcpy( &frame->board_pose, &player->board_pose, 
-                  sizeof(player->board_pose) );
-         frame->time = vg.time;
-         v3_copy( player->cam.pos, frame->cam_pos );
-         v3_copy( player->cam.angles, frame->cam_angles );
-         frame->cam_fov = player->cam.fov;
-
-         if( gamestates ){
-            replay_gamestate *gs = replay_frame_gamestate( frame, 0 );
-            gs->system = player->subsystem;
-
-            if( player->subsystem == k_player_subsystem_walk ){
-               memcpy( &gs->walk, &player->_walk.state, 
-                        sizeof(struct player_walk_state) );
-            }
-            else if( player->subsystem == k_player_subsystem_skate ){
-               memcpy( &gs->skate, &player->_skate.state, 
-                        sizeof(struct player_skate_state) );
-            }
-
-            memcpy( &gs->rb, &player->rb, sizeof(rigidbody) );
-            memcpy( &gs->cam_control, &player->cam_control, 
-                     sizeof(struct player_cam_controller) );
-            v3_copy( player->angles, gs->angles );
-         }
+   }
+}
+
+VG_STATIC void player__pre_render( player_instance *player ){
+   if( player->replay.control == k_replay_control_none ){
+      player->cam_override_strength = 0.0f;
+      player_animate( player );
+
+      if( button_down( k_srbind_reset ) && !player->immobile ){
+         audio_lock();
+         audio_oneshot( &audio_rewind[4], 1.0f, 0.0f );
+         audio_unlock();
+
+         player_record_replay( player, 1 );
+         player->replay.control = k_replay_control_scrub;
       }
+      else
+         player_record_replay( player, 0 );
+   }
+   else {
+      player->cam_override_strength = 1.0f-skaterift.time_rate;
+      player_replay_control_update( player );
+      player_animate_from_replay( player );
    }
 
    player__cam_iterate( player );

diff --git a/player_replay.c b/player_replay.c
index f0487f4b36d99a7694d60dcddf69f46d84adbe36..5f57d9f0337da280e7c4deb6cdf8ba93d9a94a9d 100644 (file)
--- a/player_replay.c
+++ b/player_replay.c
@@ -3,11 +3,19 @@
 
 #include "player_replay.h"
 
+VG_STATIC void replay_clear( replay_buffer *replay ){
+   replay->head = NULL;
+   replay->tail = NULL;
+   replay->cursor_frame = NULL;
+   replay->statehead = NULL;
+   replay->cursor = -99999.9;
+   replay->control = k_replay_control_none;
+}
+
 VG_STATIC void local_replay_init( u32 bytes ){
    localplayer.replay.data = vg_linear_alloc( vg_mem.rtmemory, bytes );
    localplayer.replay.size = bytes;
-   localplayer.replay.cursor = -9999.9;
-   vg_console_reg_var( "k_replay_test", &k_replay_test, k_var_dtype_i32, 0 );
+   replay_clear( &localplayer.replay );
 }
 
 replay_gamestate *replay_frame_gamestate( replay_frame *frame, u16 index ){
@@ -117,8 +125,8 @@ VG_STATIC void replay_seek( replay_buffer *replay, f64 t ){
    if( dir == 0.0 ) return;
    dir = vg_signf( dir );
    
-   u32 i=0;
-   for( ; i<1024; i++ ){
+   u32 i=4096;
+   while( i --> 0 ){
       if( dir < 0.0 )
          if( t > replay->cursor_frame->time ) break;
 
@@ -134,7 +142,7 @@ VG_STATIC void replay_seek( replay_buffer *replay, f64 t ){
       replay->cursor_frame = next;
       replay->cursor = next->time;
 
-      if( i == 1023 ) return;
+      if( !i ) return;
    }
 
    replay->cursor = t;
@@ -143,8 +151,8 @@ VG_STATIC void replay_seek( replay_buffer *replay, f64 t ){
 VG_STATIC replay_frame *replay_find_recent_stateframe( replay_buffer *replay ){
    replay_frame *frame = replay->cursor_frame;
 
-   u32 i=0;
-   for( ; i<4096; i++ ){
+   u32 i=4096;
+   while( i --> 0 ){
       if( !frame ) return frame;
       if( frame->gamestate_count ) return frame;
       frame = frame->l;
@@ -153,6 +161,67 @@ VG_STATIC replay_frame *replay_find_recent_stateframe( replay_buffer *replay ){
    return NULL;
 }
 
+VG_STATIC void player_replay_control_update( player_instance *player ){
+   f64 speed = 1.0;
+   f64 target = player->replay.cursor;
+
+   if( vg_getkey( SDLK_9 ) ){
+      target -= vg.time_frame_delta * speed;
+      player->replay.control = k_replay_control_scrub;
+      replay_seek( &player->replay, target );
+   }
+   if( vg_getkey( SDLK_0 ) ){
+      target += vg.time_frame_delta * speed;
+      player->replay.control = k_replay_control_scrub;
+      replay_seek( &player->replay, target );
+   }
+
+   if( vg_getkey( SDLK_7 ) )
+      player->replay.control = k_replay_control_play;
+
+   if( player->replay.control == k_replay_control_play ){
+      target += vg.time_frame_delta;
+      replay_seek( &player->replay, target );
+   }
+
+   if( vg_getkey( SDLK_8 ) ){
+      replay_frame *prev = replay_find_recent_stateframe( &player->replay );
+
+      if( prev ){
+         /* TODO: Make gamestate_apply function / swap ... */
+         replay_gamestate *gs = replay_frame_gamestate( prev, 0 );
+
+         if( gs->system == k_player_subsystem_walk ){
+            memcpy( &player->_walk.state, &gs->walk, 
+                     sizeof(struct player_walk_state) );
+         }
+         else if( gs->system == k_player_subsystem_skate ){
+            memcpy( &player->_skate.state, &gs->skate, 
+                     sizeof(struct player_skate_state) );
+         }
+         player->subsystem = gs->system;
+
+         memcpy( &player->rb, &gs->rb, sizeof(rigidbody) );
+         v3_copy( gs->angles, player->angles );
+         v3_copy( prev->cam_pos, player->cam.pos );
+         v3_copy( prev->cam_angles, player->cam_override_angles );
+         player->cam.fov = prev->cam_fov;
+         memcpy( &player->cam_control, &gs->cam_control, 
+                  sizeof(struct player_cam_controller) );
+
+         /* chop end off replay */
+         prev->r = NULL;
+         player->replay.statehead = prev;
+         player->replay.head = prev;
+         player->replay.cursor_frame = prev;
+         player->replay.cursor = prev->time;
+         player->replay.control = k_replay_control_none;
+         vg.time = prev->time;
+         return;
+      }
+   }
+}
+
 VG_STATIC void replay_debug_info( player_instance *player ){
    player__debugtext( 2, "replay info" );
 
@@ -184,7 +253,7 @@ VG_STATIC void replay_debug_info( player_instance *player ){
 }
 
 VG_STATIC void replay_imgui( player_instance *player ){
-   if( !k_replay_test ) return;
+   if( player->replay.control == k_replay_control_none ) return;
 
    replay_buffer *replay = &player->replay;
    f64 start = replay->cursor,

diff --git a/player_replay.h b/player_replay.h
index 2c18d4c68a17797ca5425f9ae8e42948baeb81fe..20eafb4c08d8081ca0b4b68b1e21af819ee1875c 100644 (file)
--- a/player_replay.h
+++ b/player_replay.h
@@ -5,8 +5,6 @@
 #include "player.h"
 #include "player_render.h"
 
-static i32 k_replay_test = 0;
-
 typedef struct replay_buffer replay_buffer;
 typedef struct replay_frame replay_frame;
 typedef struct replay_gamestate replay_gamestate;
@@ -17,14 +15,17 @@ struct replay_buffer {
    u32 size; /* bytes */
 
    enum replay_control {
+      k_replay_control_none,
       k_replay_control_scrub,
       k_replay_control_play,
+      k_replay_control_resume
    }
    control;
 
    replay_frame *head, *tail, *cursor_frame,
                 *statehead;
    f64 cursor;
+   f32 track_velocity;
 };
 
 struct replay_frame {
@@ -66,5 +67,6 @@ VG_STATIC void replay_seek( replay_buffer *replay, f64 t );
 replay_gamestate *replay_frame_gamestate( replay_frame *frame, u16 index );
 replay_sfx *replay_frame_sfx( replay_frame *frame, u16 index );
 VG_STATIC replay_frame *replay_find_recent_stateframe( replay_buffer *replay );
+VG_STATIC void player_replay_control_update( player_instance *player );
 
 #endif /* PLAYER_REPLAY_H */

diff --git a/skaterift.c b/skaterift.c
index 3fec7e0e6a3161ab4dd792aecb223909cc0ede9c..5d86c94e9dc0a6db201f2d5e3d7b241cce7de5a9 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -320,9 +320,10 @@ VG_STATIC void vg_update_post(void){
    v3_copy( localplayer.rb.v, vg_audio.external_lister_velocity );
    audio_unlock();
 
-   f32 target = 1.0f-(f32)(menu.active||k_replay_test);
-   skaterift.time_rate = vg_lerpf( skaterift.time_rate, target,
-                                   vg.time_frame_delta * 6.0f );
+   int replay_open = localplayer.replay.control != k_replay_control_none?1:0;
+
+   f32 target = (1-(menu.active||replay_open));
+   vg_slewf( &skaterift.time_rate, target, vg.time_frame_delta * 6.0f );
 
    vg.time_rate = skaterift.time_rate;
    vehicle_update_post();