add glider&orphan data to replay

diff --git a/player.c b/player.c
index 6eed52f14693ee2b70f1942a3e5d148820ba692d..1d690a088bab23a0e39225d9561d8ed167f597ae 100644 (file)
--- a/player.c
+++ b/player.c
@@ -113,7 +113,8 @@ static void player__update(void){
    if( player_subsystems[ localplayer.subsystem ]->update )
       player_subsystems[ localplayer.subsystem ]->update();
 
-   if( localplayer.glider_orphan )
+   if( localplayer.glider_orphan && 
+       (skaterift.activity != k_skaterift_replay) )
       glider_physics( (v2f){0,0} );
 }
 

diff --git a/player_glide.c b/player_glide.c
index 5cf1dd11a6ce15fd040f743063198e1644fa4a78..95337b240bc1b84fe86a8aeb9ebd047c2ee68f63 100644 (file)
--- a/player_glide.c
+++ b/player_glide.c
@@ -230,14 +230,15 @@ static void player_glide_animate(void){
 static void player_glide_pose( void *_animator, player_pose *pose ){
    struct skeleton *sk = &localplayer.skeleton;
    struct player_glide_animator *animator = _animator;
+   pose->type = k_player_pose_type_ik;
+   pose->board.lean = 0.0f;
 
    skeleton_sample_anim( sk, player_glide.anim_glide, 0.0f, pose->keyframes );
 
-   /* TODO: again the offset is wrong */
    v3f temp;
-   q_mulv( pose->root_q, (v3f){0,-0.5f,0}, temp );
-
+   q_mulv( animator->root_q, (v3f){0,-0.5f,0}, temp );
    v3_add( animator->root_co, temp, pose->root_co );
+
    v4_copy( animator->root_q, pose->root_q );
 }
 
@@ -339,7 +340,6 @@ static void player_glide_bind(void){
    struct skeleton *sk = &localplayer.skeleton;
    player_glide.anim_glide = skeleton_get_anim( sk, "glide_pose" );
 
-
    void *alloc = vg_mem.rtmemory;
    mdl_context *mdl = &player_glide.glider;
 
@@ -394,9 +394,16 @@ static void player_glide_transition(void){
    player__begin_holdout( (v3f){0,0,0} );
 }
 
+/*
+ * TODO: more flexible way to call
+ *      - this depends on the current state, but we need to pass a struct in
+ *        that can hold that information instead so we can save it into 
+ *        the replay
+ */
 static void player_glide_render( camera *cam, world_instance *world,
                                  player_pose *pose ){
    if( !((localplayer.subsystem == k_player_subsystem_glide) ||
+         (localplayer.observing_system == k_player_subsystem_glide) ||
           localplayer.have_glider ||
           localplayer.glider_orphan) )
       return;
@@ -428,7 +435,10 @@ static void player_glide_render( camera *cam, world_instance *world,
       f32 target;
       if( localplayer.subsystem == k_player_subsystem_glide ) target = 1.0f;
       else target = 0.0f;
-      vg_slewf( &player_glide.t, target, vg.time_frame_delta * 4.0f );
+
+      /* TODO: TEMP */
+      if( skaterift.activity != k_skaterift_replay )
+         vg_slewf( &player_glide.t, target, vg.time_frame_delta * 4.0f );
 
       mdl_keyframe kf_backpack;
 

diff --git a/player_render.c b/player_render.c
index c1e96f67864dc82a37924240f28283c7bb9ce000..3498a0a70dc8196fb904000e875f7a355bbd0b78 100644 (file)
--- a/player_render.c
+++ b/player_render.c
@@ -331,8 +331,14 @@ static void player__animate_from_replay( replay_buffer *replay ){
          *sys0 = player_subsystems[frame->system];
       void *a0 = replay_frame_data( frame, k_replay_framedata_animator );
 
+      struct replay_glider_data 
+         *g0 = replay_frame_data( frame, k_replay_framedata_glider ),
+         *g1;
+
+      f32 t = 0.0f;
+
       if( next ){
-         f32 t = replay_subframe_time( replay );
+         t = replay_subframe_time( replay );
 
          player_pose pose0, pose1;
 
@@ -344,14 +350,44 @@ static void player__animate_from_replay( replay_buffer *replay ){
          sys1->pose( a1, &pose1 );
 
          lerp_player_pose( &pose0, &pose1, t, &localplayer.pose );
+         g1 = replay_frame_data( next,  k_replay_framedata_glider );
       }
       else{
          sys0->pose( a0, &localplayer.pose );
+         g1 = NULL;
       }
 
       player__observe_system( frame->system );
       if( sys0->sfx_comp ) 
          sys0->sfx_comp( a0 );
+
+      if( g0 ){
+         if( g0->glider_orphan ){
+            if( g1 ){
+               v3_lerp( g0->co, g1->co, t, player_glide.rb.co );
+               q_nlerp( g0->q,  g1->q,  t, player_glide.rb.q );
+            }
+            else {
+               v3_copy( g0->co, player_glide.rb.co );
+               v4_copy( g0->q,  player_glide.rb.q );
+            }
+
+            rb_update_matrices( &player_glide.rb );
+         }
+
+         if( g1 )
+            player_glide.t = vg_lerpf( g0->t, g1->t, t );
+         else
+            player_glide.t = g0->t;
+
+         localplayer.have_glider   = g0->have_glider;
+         localplayer.glider_orphan = g0->glider_orphan;
+      }
+      else /* no glider data in g1, or edge case we dont care about */ {
+         localplayer.have_glider = 0;
+         localplayer.glider_orphan = 0;
+         player_glide.t = 0.0f;
+      }
    }
    else return;
 

diff --git a/player_replay.c b/player_replay.c
index 6c7840cdf9620e13d5157e6bb59aeacb038954f2..a013f7ce4059dc9222adb2145ec2f9c919def399 100644 (file)
--- a/player_replay.c
+++ b/player_replay.c
@@ -16,14 +16,18 @@ static void replay_clear( replay_buffer *replay ){
 
 static 
 void * replay_frame_data( replay_frame *frame, enum replay_framedata type ){
+   if( frame->data_table[type][1] == 0 )
+      return NULL;
+
    void *baseptr = frame;
    return baseptr + frame->data_table[type][0];
 }
 
-static u16
-replay_frame_calculate_data_offsets( u16 data_table[4][2] ){
+static u16 replay_frame_calculate_data_offsets( 
+      u16 data_table[k_replay_framedata_rows][2] ){
+
    u32 total = vg_align8( sizeof(replay_frame) );
-   for( u32 i=0; i<4; i++ ){
+   for( u32 i=0; i<k_replay_framedata_rows; i++ ){
       data_table[i][0] = total;
       total += vg_align8(data_table[i][1]);
 
@@ -50,8 +54,9 @@ static void replay_tailpop( replay_buffer *replay ){
 static replay_frame *replay_newframe( replay_buffer *replay, 
                                          u16 animator_size,
                                          u16 gamestate_size,
-                                         u16 sfx_count ){
-   u16 data_table[4][2];
+                                         u16 sfx_count,
+                                         bool save_glider ){
+   u16 data_table[ k_replay_framedata_rows ][2];
    data_table[ k_replay_framedata_animator ][1]  = animator_size;
    data_table[ k_replay_framedata_gamestate ][1] = gamestate_size;
    data_table[ k_replay_framedata_sfx ][1] = sfx_count*sizeof(struct net_sfx);
@@ -61,6 +66,12 @@ static replay_frame *replay_newframe( replay_buffer *replay,
          sizeof( replay_gamestate );
    }
 
+   data_table[ k_replay_framedata_glider ][1] = 0;
+   if( save_glider ){
+      data_table[ k_replay_framedata_glider ][1] = 
+         sizeof(struct replay_glider_data);
+   }
+
    u32 nextsize = replay_frame_calculate_data_offsets( data_table );
 
    replay_frame *frame = NULL;
@@ -99,7 +110,7 @@ check_again:;
    else
       frame = replay->data;
 
-   for( u32 i=0; i<4; i++ ){
+   for( u32 i=0; i<k_replay_framedata_rows; i++ ){
       frame->data_table[i][0] = data_table[i][0];
       frame->data_table[i][1] = data_table[i][1];
    }
@@ -256,13 +267,19 @@ static void skaterift_record_frame( replay_buffer *replay,
              k_gamestate_rate = 0.5;
 
    int save_frame = 0,
-       save_state = 0;
+       save_state = 0,
+       save_glider = 0;
 
    if( force_gamestate ) save_state = 1;
    if( statedelta > k_gamestate_rate ) save_state = 1;
    if( delta > k_replay_rate ) save_frame = 1;
    if( save_state ) save_frame = 1;
 
+   if( localplayer.have_glider || localplayer.glider_orphan ||
+       localplayer.subsystem == k_player_subsystem_glide ){
+      save_glider = 1;
+   }
+
    if( !save_frame ) return;
 
    u16 gamestate_size = 0;
@@ -274,7 +291,7 @@ static void skaterift_record_frame( replay_buffer *replay,
          [k_player_subsystem_skate] = sizeof(struct player_skate_state),
          [k_player_subsystem_dead ] = localplayer.ragdoll.part_count * 
                                        sizeof(struct replay_rb),
-         [k_player_subsystem_glide] = 0,
+         [k_player_subsystem_glide] = sizeof(struct replay_rb),
       }[ localplayer.subsystem ];
    }
 
@@ -282,7 +299,8 @@ static void skaterift_record_frame( replay_buffer *replay,
    
    replay_frame *frame = replay_newframe( replay,
                                           animator_size, gamestate_size, 
-                                          localplayer.local_sfx_buffer_count );
+                                          localplayer.local_sfx_buffer_count,
+                                          save_glider );
    frame->system = localplayer.subsystem;
 
    if( save_state ){
@@ -291,10 +309,10 @@ static void skaterift_record_frame( replay_buffer *replay,
 
       /* permanent block */
       memcpy( &gs->rb, &localplayer.rb, sizeof(rigidbody) );
+      memcpy( &gs->glider_rb, &player_glide.rb, sizeof(rigidbody) );
       memcpy( &gs->cam_control, &localplayer.cam_control, 
                sizeof(struct player_cam_controller) );
       v3_copy( localplayer.angles, gs->angles );
-      gs->have_glider = localplayer.have_glider;
 
       void *dst = replay_frame_data( frame, k_replay_framedata_gamestate );
 
@@ -313,6 +331,25 @@ static void skaterift_record_frame( replay_buffer *replay,
             v4_copy( rb->q, arr[i].q );
          }
       }
+      else if( localplayer.subsystem == k_player_subsystem_glide ){
+         struct replay_rb *arr = dst;
+         rigidbody *rb = &player_glide.rb;
+         v3_copy( rb->co, arr[0].co );
+         v3_copy( rb->w, arr[0].w );
+         v3_copy( rb->v, arr[0].v );
+         v4_copy( rb->q, arr[0].q );
+      }
+   }
+
+   if( save_glider ){
+      struct replay_glider_data *inf = 
+         replay_frame_data( frame, k_replay_framedata_glider );
+
+      inf->have_glider   = localplayer.have_glider;
+      inf->glider_orphan = localplayer.glider_orphan;
+      inf->t             = player_glide.t;
+      v3_copy( player_glide.rb.co, inf->co );
+      v4_copy( player_glide.rb.q,  inf->q );
    }
 
    replay->cursor = vg.time;
@@ -336,18 +373,9 @@ static void skaterift_record_frame( replay_buffer *replay,
    frame->cam_fov = localplayer.cam.fov;
 
    /* animator */
-   void *dst = replay_frame_data( frame, k_replay_framedata_animator );
-
-   if( localplayer.subsystem == k_player_subsystem_walk )
-      memcpy( dst, &player_walk.animator, animator_size );
-   else if( localplayer.subsystem == k_player_subsystem_skate )
-      memcpy( dst, &player_skate.animator, animator_size );
-   else if( localplayer.subsystem == k_player_subsystem_dead ){
-      memcpy( dst, &player_dead.animator, animator_size );
-   }
-   else if( localplayer.subsystem == k_player_subsystem_glide ){
-      memcpy( dst, &player_glide.animator, animator_size );
-   }
+   void *dst = replay_frame_data( frame, k_replay_framedata_animator ),
+        *src = player_subsystems[localplayer.subsystem]->animator_data;
+   memcpy( dst, src, animator_size );
 
    /* sound effects */
    memcpy( replay_frame_data( frame, k_replay_framedata_sfx ),
@@ -386,13 +414,38 @@ void skaterift_restore_frame( replay_frame *frame ){
 
          v3_copy( arr[i].co, part->prev_co );
          v4_copy( arr[i].q, part->prev_q );
+         rb_update_matrices( rb );
       }
    }
+   else if( frame->system == k_player_subsystem_glide ){
+      struct replay_rb *arr = src;
+      rigidbody *rb = &player_glide.rb;
+      v3_copy( arr[0].co, rb->co );
+      v3_copy( arr[0].w, rb->w );
+      v3_copy( arr[0].v, rb->v );
+      v4_copy( arr[0].q, rb->q );
+      rb_update_matrices( rb );
+   }
+
+   /* restore the seperated glider data if we have it */
+   if( frame->data_table[ k_replay_framedata_glider ][1] ){
+      localplayer.subsystem = frame->system;
+
+      struct replay_glider_data *inf = 
+         replay_frame_data( frame, k_replay_framedata_glider );
 
-   localplayer.subsystem = frame->system;
-   localplayer.have_glider = gs->have_glider;
+      localplayer.have_glider   = inf->have_glider;
+      localplayer.glider_orphan = inf->glider_orphan;
+      player_glide.t            = inf->t;
+   }
+   else {
+      localplayer.have_glider = 0;
+      localplayer.glider_orphan = 0;
+      player_glide.t = 0.0f;
+   }
 
    memcpy( &localplayer.rb, &gs->rb, sizeof(rigidbody) );
+   memcpy( &player_glide.rb, &gs->glider_rb, sizeof(rigidbody) );
    v3_copy( gs->angles, localplayer.angles );
 
    v3_copy( frame->cam_pos, localplayer.cam.pos );
@@ -516,8 +569,10 @@ static void skaterift_replay_update_helpers(void){
 }
 
 static void skaterift_replay_post_render(void){
+#ifndef SR_ALLOW_REWIND_HUB
    if( world_static.active_instance != k_world_purpose_client )
       return;
+#endif
 
    /* capture the current resume frame at the very last point */
    if( button_down( k_srbind_reset ) ){
@@ -552,21 +607,6 @@ static void skaterift_replay_post_render(void){
    }
 }
 
-#if 0
-static void skaterift_get_replay_camera( camera *cam ){
-   if( skaterift.freecam ){
-      cam->nearz = 0.1f;
-      cam->farz = 100.0f;
-      v3_copy( skaterift.replay_freecam.pos, cam->pos );
-      v3_copy( skaterift.replay_freecam.angles, cam->angles );
-      cam->fov = skaterift.replay_freecam.fov;
-   }
-   else{
-      replay_get_camera( &skaterift.replay, &skaterift.cam );
-   }
-}
-#endif
-
 static void skaterift_replay_debug_info(void){
    player__debugtext( 2, "replay info" );
 
@@ -580,7 +620,7 @@ static void skaterift_replay_debug_info(void){
    player__debugtext( 1, "head @%u | tail @%u\n", head, tail );
 
    if( replay->statehead ){
-      for( u32 i=0; i<4; i++ ){
+      for( u32 i=0; i<k_replay_framedata_rows; i++ ){
          player__debugtext( 1, "[%u]: [%hu, %hu]\n", i,
               replay->statehead->data_table[i][0],
               replay->statehead->data_table[i][1] );

diff --git a/player_replay.h b/player_replay.h
index 58bc8d328e94e42dcd108dba5d8a8cab4b779455..42d9bf71d768f731964e6195615647acf6e4ecfc 100644 (file)
--- a/player_replay.h
+++ b/player_replay.h
@@ -23,7 +23,9 @@ enum replay_framedata{
    k_replay_framedata_animator,
    k_replay_framedata_gamestate,
    k_replay_framedata_internal_gamestate,
-   k_replay_framedata_sfx
+   k_replay_framedata_sfx,
+   k_replay_framedata_glider,
+   k_replay_framedata_rows
 };
 
 struct replay_frame {
@@ -35,24 +37,28 @@ struct replay_frame {
 
    enum player_subsystem system;
    u16 total_size;
-   u16 data_table[4][2];
+   u16 data_table[k_replay_framedata_rows][2];
 };
 
 struct replay_gamestate {
-   rigidbody rb;
+   rigidbody rb, glider_rb; /* TODO: these don't need to be saved with their 
+                                     full matrices */
    v3f angles;
-   bool have_glider;
    struct player_cam_controller cam_control;
 };
 
+/* we save this per-anim-frame. if there glider is existing in any state */
+struct replay_glider_data {
+   bool have_glider, glider_orphan;
+   f32 t;
+   v3f co; 
+   v4f q;
+};
+
 struct replay_sfx {
    u32 none;
 };
 
-static replay_frame *replay_newframe( replay_buffer *replay, 
-                                         u16 animator_size,
-                                         u16 gamestate_size,
-                                         u16 sfx_count );
 static int replay_seek( replay_buffer *replay, f64 t );
 
 static replay_frame *replay_find_recent_stateframe( replay_buffer *replay );

diff --git a/shaders/scene_water_fast.h b/shaders/scene_water_fast.h
index 7c5a079106558d9cf0849b517a08098bb36d0582..ac987dd5204c6f15feb79c77bc4d6fff46469757 100644 (file)
--- a/shaders/scene_water_fast.h
+++ b/shaders/scene_water_fast.h
@@ -510,6 +510,7 @@ static struct vg_shader _shader_scene_water_fast = {
 "   vec4 vsurface = water_surf( halfview, surfnorm, depthvalue );\n"
 "   vsurface.a -= fdist;\n"
 "   oColour = mix( vsurface, vec4(1.0,1.0,1.0,0.5), fband );\n"
+"   oColour.rgb = scene_compute_lighting( oColour.rgb, aNorm.xyz, aWorldCo );\n"
 "}\n"
 ""},
 };

diff --git a/skaterift.c b/skaterift.c
index 820834784e276308c16199ceaff84cfbe382f981..ae34d5b0eee487b654b9a93391773b39becab5d1 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -14,6 +14,7 @@
 #define SR_NETWORKED
 #define VG_AUDIO_FORCE_COMPRESSED
 #define SDL_MAIN_HANDLED
+//#define SR_ALLOW_REWIND_HUB
 
 #ifndef VG_RELEASE
  #define VG_DEVWINDOW