X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_device_skate.h;h=d4c1e6201803e795fac6382d35c4b3c00792dc79;hb=23ef4d7f6bfe6a5a91c78822b081a9ea63cb74a6;hp=62c21210b9bd29fd9e89950ec57058c54fe51b59;hpb=03aada77bbf0d268216a4ace0281ccb97ea9a409;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_device_skate.h b/player_device_skate.h
index 62c2121..d4c1e62 100644
--- a/player_device_skate.h
+++ b/player_device_skate.h
@@ -43,7 +43,8 @@ struct player_device_skate
       double start_push,
              cur_push;
 
-      v3f vl;
+      v3f vl, follow_cam_pos;
+      struct teleport_gate *follow_cam_gate;
    }
    state,
    state_gate_storage;
@@ -1149,6 +1150,14 @@ VG_STATIC void player_skate_update( player_interface *player,
    skate_apply_air_model( player, s );
 
    skate_integrate( player, s );
+
+   vg_line_pt3( s->state.cog, 0.1f,  VG__WHITE );
+   vg_line_pt3( s->state.cog, 0.11f, VG__WHITE );
+   vg_line_pt3( s->state.cog, 0.12f, VG__WHITE );
+   vg_line_pt3( s->state.cog, 0.13f, VG__WHITE );
+   vg_line_pt3( s->state.cog, 0.14f, VG__WHITE );
+
+   vg_line( player->rb.co, s->state.cog, VG__RED );
 }
 
 VG_STATIC void player_skate_post_update( player_interface *player,
@@ -1182,6 +1191,11 @@ VG_STATIC void player_skate_ui( player_interface *player,
                         k_steer_ground, k_steer_air );
 }
 
+VG_STATIC void skate_camera_thirdperson_nextpos( player_interface *player,
+                                                 struct player_device_skate *s,
+                                                 struct player_avatar *av,
+                                                 v3f next_pos, v3f d );
+
 VG_STATIC void player_skate_pose( player_interface *player,
                                   player_attachment *at, 
                                   player_pose pose, m4x3f transform )
@@ -1211,6 +1225,9 @@ VG_STATIC void player_skate_pose( player_interface *player,
    v3f offset;
    v3_zero( offset );
 
+   m4x3_mulv( player->rb.to_local, s->state.cog, offset );
+   v3_muls( offset, -4.0f, offset );
+
 #if 0
    m3x3_mulv( player.inv_visual_transform, phys->bob, offset );
 #endif
@@ -1394,10 +1411,7 @@ VG_STATIC void player_skate_pose( player_interface *player,
    /* transform */
    rb_extrapolate_transform( &player->rb, transform );
 
-#if 0
-   v3_muladds( player.visual_transform[3], phys->rb.up, -0.2f, 
-               player.visual_transform[3] );
-#endif
+   v3_muladds( transform[3], player->rb.to_world[1], -0.28f, transform[3] );
 
    v4f qresy, qresx, qresidual;
    m3x3f mtx_residual;
@@ -1408,14 +1422,42 @@ VG_STATIC void player_skate_pose( player_interface *player,
    q_mul( qresy, qresx, qresidual );
    q_m3x3( qresidual, mtx_residual );
    m3x3_mul( transform, mtx_residual, transform );
+
+   if( cl_thirdperson && s->state.follow_cam_gate )
+   {
+      v3f next_pos, d, _;
+      skate_camera_thirdperson_nextpos( player, s, av, next_pos, d );
+
+      if( !gate_intersect_plane( s->state.follow_cam_gate, 
+                                 next_pos, s->state.follow_cam_pos, _ ) )
+      {
+         m4x3f inverse;
+         m4x3_invert_affine( s->state.follow_cam_gate->transport, inverse );
+         m4x3_mul( inverse, transform, transform );
+      }
+   }
 }
 
-VG_STATIC void player_skate_get_camera( player_interface *player,
-                                        player_attachment *at, camera *cam )
+VG_STATIC void skate_camera_vector_look( camera *cam, v3f v, float C, float k )
 {
-   struct player_device_skate *s = at->storage;
-   struct player_avatar *av = player->playeravatar;
+   float yaw = atan2f( v[0], -v[2] ),
+       pitch = atan2f
+               ( 
+                   -v[1], 
+                   sqrtf
+                   (
+                     v[0]*v[0] + v[2]*v[2]
+                   )
+               ) * C + k;
+
+   cam->angles[0] = yaw;
+   cam->angles[1] = pitch;
+}
 
+VG_STATIC void skate_camera_firstperson( player_interface *player,
+                                         struct player_device_skate *s,
+                                         struct player_avatar *av, camera *cam )
+{
    /* FIXME: viewpoint entity */
    v3f vp = {-0.1f,1.8f,0.0f};
    m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, cam->pos );
@@ -1428,7 +1470,7 @@ VG_STATIC void player_skate_get_camera( player_interface *player,
        look_dir;
 
    v3_copy( player->rb.v, vel_dir );
-   v3_normalize( vel_dir );
+   //v3_normalize( vel_dir );
 
    float tti = s->land_dist;
    v3f   norm;
@@ -1440,27 +1482,93 @@ VG_STATIC void player_skate_get_camera( player_interface *player,
       v3_copy( player->rb.to_world[1], norm );
    }
 
-
    v3_muladds( vel_dir, norm, -v3_dot(vel_dir,norm), flat_dir );
-   v3_normalize( flat_dir );
+   //v3_normalize( flat_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, 8.0f*vg.time_delta, s->state.vl );
+   v3_lerp( s->state.vl, look_dir, 4.0f*vg.time_delta, s->state.vl );
 
-   float *v  = s->state.vl,
-         yaw = atan2f( v[0], -v[2] ),
-       pitch = atan2f
-               ( 
-                   -v[1], 
-                   sqrtf
-                   (
-                     v[0]*v[0] + v[2]*v[2]
-                   )
-               ) 
-               * 0.7f + 0.5f;
+   skate_camera_vector_look( cam, s->state.vl, 0.7f, 0.5f );
+}
 
-   cam->angles[0] = yaw;
-   cam->angles[1] = pitch;
+/* this is a little yucky but needs to be done so we can use this 'prediction' 
+ * in the pose function. its unfortunate. too bad
+ */
+VG_STATIC void skate_camera_thirdperson_nextpos( player_interface *player,
+                                                 struct player_device_skate *s,
+                                                 struct player_avatar *av,
+                                                 v3f next_pos, v3f d )
+{
+   v3f origin, target;
+
+   if( s->state.follow_cam_gate )
+   {
+      m4x3f inverse;
+      m4x3_invert_affine( s->state.follow_cam_gate->transport, inverse );
+      m4x3_mulv( inverse, player->rb.co, origin );
+   }
+   else
+   {
+      v3_copy( player->rb.co, origin );
+   }
+
+   v3_add( origin, (v3f){0.0f,1.35f,0.0f}, origin );
+   v3_sub( origin, s->state.follow_cam_pos, d );
+   
+   if( v3_length2( d ) < 0.1f*0.1f )
+      v3_copy( (v3f){ 0.0f, 0.0f, 1.0f }, d );
+   else
+      v3_normalize( d );
+
+   v3_muladds( origin, d, -2.0f, target );
+   v3_lerp( s->state.follow_cam_pos, target, vg.frame_delta * 12.0f, next_pos );
+}
+
+VG_STATIC void skate_camera_thirdperson( player_interface *player,
+                                         struct player_device_skate *s,
+                                         struct player_avatar *av, camera *cam )
+{
+   v3f prev_pos, cam_look_dir, d;
+
+   v3_copy( s->state.follow_cam_pos, prev_pos );
+   skate_camera_thirdperson_nextpos( player, s, av, s->state.follow_cam_pos, d);
+
+   if( s->state.follow_cam_gate )
+   {
+      v2f _;
+      if( gate_intersect_plane( s->state.follow_cam_gate, 
+                                s->state.follow_cam_pos, prev_pos, _ ) )
+      {
+         m4x3_mulv( s->state.follow_cam_gate->transport, 
+                        s->state.follow_cam_pos, s->state.follow_cam_pos );
+         m3x3_mulv( s->state.follow_cam_gate->transport, d, d );
+         player_apply_transport_to_cam( s->state.follow_cam_gate->transport );
+
+         s->state.follow_cam_gate = NULL;
+      }
+   }
+   
+   skate_camera_vector_look( cam, d, 1.0f, 0.0f );
+   v3_copy( s->state.follow_cam_pos, cam->pos );
+}
+
+VG_STATIC void player_skate_get_camera( player_interface *player,
+                                        player_attachment *at, camera *cam )
+{
+   struct player_device_skate *s = at->storage;
+   struct player_avatar *av = player->playeravatar;
+
+   if( cl_thirdperson )
+      skate_camera_thirdperson( player, s, av, cam );
+   else
+      skate_camera_firstperson( player, s, av, cam );
+
+   /* 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_skate_transport( player_interface *player,
@@ -1470,16 +1578,33 @@ VG_STATIC void player_skate_transport( player_interface *player,
    struct player_device_skate *s = at->storage;
 
    m4x3_mulv( gate->transport, player->rb.co,  player->rb.co );
+   m3x3_mulv( gate->transport, player->rb.v,   player->rb.v );
    m4x3_mulv( gate->transport, s->state.cog,   s->state.cog );
    m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
-   m3x3_mulv( gate->transport, player->rb.v,   player->rb.v );
    m3x3_mulv( gate->transport, s->state.vl,    s->state.vl );
+   m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
 
    v4f transport_rotation;
    m3x3_q( gate->transport, transport_rotation );
    q_mul( transport_rotation, player->rb.q, player->rb.q );
+   rb_update_transform( &player->rb );
 
+   s->state.follow_cam_gate = gate;
    s->state_gate_storage = s->state;
+
+   if( !cl_thirdperson )
+   {
+      player_apply_transport_to_cam( gate->transport );
+   }
+}
+
+VG_STATIC void player_skate_reset( player_interface *player,
+                                   player_attachment *at,
+                                   struct respawn_point *rp )
+{
+   struct player_device_skate *s = at->storage;
+   v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
+   s->state.follow_cam_gate = NULL;
 }
 
 VG_STATIC player_device player_device_skate =
@@ -1491,7 +1616,8 @@ VG_STATIC player_device player_device_skate =
    .debug_ui      = player_skate_ui,
    .bind          = player_skate_bind,
    .pose          = player_skate_pose,
-   .gate_transport= player_skate_transport
+   .gate_transport= player_skate_transport,
+   .reset         = player_skate_reset
 };
 
 #endif /* PLAYER_DEVICE_SKATE_H */