CCD!

diff --git a/maps_src/mp_gridmap.mdl b/maps_src/mp_gridmap.mdl
index 7efdc8a2322305c47ddc4001be9ac5a397e9354d..676155a61d3ae5d944bd35154a1a14d29d199fa2 100644 (file)
Binary files a/maps_src/mp_gridmap.mdl and b/maps_src/mp_gridmap.mdl differ

diff --git a/player_skate.c b/player_skate.c
index be356676872b52024c1c0002979749b6304f73c1..b2d951e9026e07bccd3beed2b716deb454914a5f 100644 (file)
--- a/player_skate.c
+++ b/player_skate.c
@@ -113,8 +113,8 @@ VG_STATIC int skate_grind_collide( player_instance *player, rb_ct *contact )
    v3f p0, p1, c0, c1;
    v3_muladds( player->rb.co, player->rb.to_world[2],  0.5f, p0 );
    v3_muladds( player->rb.co, player->rb.to_world[2], -0.5f, p1 );
-   v3_muladds( p0, player->rb.to_world[1], 0.125f-0.15f, p0 );
-   v3_muladds( p1, player->rb.to_world[1], 0.125f-0.15f, p1 );
+   v3_muladds( p0, player->rb.to_world[1], 0.08f, p0 );
+   v3_muladds( p1, player->rb.to_world[1], 0.08f, p1 );
 
    float const k_r = 0.25f;
    struct grind_edge *closest_edge = skate_collect_grind_edge( p0, p1, 
@@ -615,6 +615,8 @@ VG_STATIC int skate_simulate_spring( player_instance *player,
 
 /* 
  * Handles connection between the player and the ground
+ *
+ * TODO: Must save original velocity to use here
  */
 VG_STATIC void skate_apply_interface_model( player_instance *player,
                                             rb_ct *manifold, int len )
@@ -701,6 +703,7 @@ VG_STATIC void skate_apply_interface_model( player_instance *player,
          float angle = v3_dot( player->rb.to_world[1], projected );
          v3_cross( player->rb.to_world[1], projected, axis );
 
+#if 0
          if( fabsf(angle) < 0.9999f )
          {
             v4f correction;
@@ -708,6 +711,7 @@ VG_STATIC void skate_apply_interface_model( player_instance *player,
                           acosf(angle)*4.0f*VG_TIMESTEP_FIXED );
             q_mul( correction, player->rb.q, player->rb.q );
          }
+#endif
       }
    }
 }
@@ -1061,10 +1065,12 @@ VG_STATIC void skate_collision_response( player_instance *player,
           */
          
          float wy = v3_dot( player->rb.to_world[1], impulse ) * 0.8f,
-               wx = v3_dot( player->rb.to_world[0], impulse ) * 1.0f;
+               wx = v3_dot( player->rb.to_world[0], impulse ) * 1.0f,
+               wz = v3_dot( player->rb.to_world[2], impulse ) * 2.0f;
 
          v3_muladds( player->rb.w, player->rb.to_world[1], wy, player->rb.w );
          v3_muladds( player->rb.w, player->rb.to_world[0], wx, player->rb.w );
+         v3_muladds( player->rb.w, player->rb.to_world[2], wz, player->rb.w );
       }
    }
 }
@@ -1074,9 +1080,11 @@ VG_STATIC void skate_integrate( player_instance *player )
    struct player_skate *s = &player->_skate;
 
    /* integrate rigidbody velocities */
+#ifndef SKATE_CCD
    v3f gravity = { 0.0f, -9.6f, 0.0f };
    v3_muladds( player->rb.v, gravity, k_rb_delta, player->rb.v );
    v3_muladds( player->rb.co, player->rb.v, k_rb_delta, player->rb.co );
+#endif
 
    float decay_rate = 0.5f*0.125f;
 
@@ -1088,6 +1096,7 @@ VG_STATIC void skate_integrate( player_instance *player )
 
    v3_lerp( player->rb.w, (v3f){0.0f,0.0f,0.0f}, decay_rate, player->rb.w );
 
+#ifndef SKATE_CCD
    if( v3_length2( player->rb.w ) > 0.0f )
    {
       v4f rotation;
@@ -1099,6 +1108,7 @@ VG_STATIC void skate_integrate( player_instance *player )
       q_axis_angle( rotation, axis, mag*k_rb_delta );
       q_mul( rotation, player->rb.q, player->rb.q );
    }
+#endif
 
    /* integrate steering velocities */
    v4f rotate; 
@@ -1203,72 +1213,186 @@ VG_STATIC void player__skate_update( player_instance *player )
    v3_copy( player->rb.co, s->state.prev_pos );
    s->state.activity_prev = s->state.activity;
 
-   /* Setup colliders */
-   m4x3f mtx_front, mtx_back;
-   m3x3_identity( mtx_front );
-   m3x3_identity( mtx_back );
+   float l = k_board_length,
+         w = 0.13f;
+
+   v3f wheel_positions[] = 
+   {
+      { -w, 0.0f, -l },
+      {  w, 0.0f, -l },
+      { -w, 0.0f,  l },
+      {  w, 0.0f,  l },
+   };
+
+   rb_sphere collider;
+   collider.radius = 0.07f;
+
+   s->substep = k_rb_delta;
+
+begin_collision:;
+
+#ifdef SKATE_CCD
+
+   /* calculate transform one step into future */
+   v3f future_co;
+   v4f future_q;
+   v3_muladds( player->rb.co, player->rb.v, s->substep, future_co );
+
+   if( v3_length2( player->rb.w ) > 0.0f )
+   {
+      v4f rotation;
+      v3f axis;
+      v3_copy( player->rb.w, axis );
+      
+      float mag = v3_length( axis );
+      v3_divs( axis, mag, axis );
+      q_axis_angle( rotation, axis, mag*s->substep );
+      q_mul( rotation, player->rb.q, future_q );
+      q_normalize( future_q );
+   }
+
+   /* calculate the minimum time we can move */
+   float max_time = s->substep,
+         cast_radius = collider.radius - 0.05f;
+
+   for( int i=0; i<4; i++ )
+   {
+      v3f current, future;
+      q_mulv( future_q, wheel_positions[i], future );
+      v3_add( future, future_co, future );
 
-   skate_get_board_points( player, mtx_front[3], mtx_back[3] );
+      q_mulv( player->rb.q, wheel_positions[i], current );
+      v3_add( current, player->rb.co, current );
+      
+      float t;    /* TODO: ignore lightly grazing normals? */
+      v3f n;
+      if( spherecast_world( current, future, cast_radius, &t, n ) != -1)
+      {
+         max_time = vg_minf( max_time, t * s->substep );
+      }
+   }
+
+   /* clamp to a fraction of delta, to prevent locking */
+   max_time = vg_minf( vg_maxf( max_time, k_rb_delta*0.025f ), s->substep );
+   s->substep_delta = max_time;
+
+   /* integrate */
+   v3_muladds( player->rb.co, player->rb.v, s->substep_delta, player->rb.co );
+   if( v3_length2( player->rb.w ) > 0.0f )
+   {
+      v4f rotation;
+      v3f axis;
+      v3_copy( player->rb.w, axis );
+      
+      float mag = v3_length( axis );
+      v3_divs( axis, mag, axis );
+      q_axis_angle( rotation, axis, mag*s->substep_delta );
+      q_mul( rotation, player->rb.q, player->rb.q );
+   }
+
+   rb_update_transform( &player->rb );
+
+   v3f gravity = { 0.0f, -9.6f, 0.0f };
+   v3_muladds( player->rb.v, gravity, s->substep_delta, player->rb.v );
+
+#else
+   
+   s->substep_delta = k_rb_delta;
+
+#endif
+
+   s->substep -= s->substep_delta;
 
-   s->sphere_back.radius = 0.3f;
-   s->sphere_front.radius = 0.3f;
 
    /* create manifold(s) */
-   rb_ct manifold[72],
-         *interface_manifold = NULL,
-         *grind_manifold = NULL;
+   rb_ct manifold[128];
+
+   int manifold_len   = 0,
+       manifold_front = 0,
+       manifold_back  = 0,
+       manifold_interface = 0;
+
+   rb_ct *cmanifold = manifold;
+
+   for( int i=0; i<4; i++ )
+   {
+      m4x3f mtx;
+      m3x3_identity( mtx );
+
+      m4x3_mulv( player->rb.to_world, wheel_positions[i], mtx[3] );
+      
+      int l = skate_collide_smooth( player, mtx, &collider, cmanifold );
 
-   int 
-   len_front = skate_collide_smooth( player, mtx_front, 
-                                     &s->sphere_front, manifold ),
-   len_back = skate_collide_smooth( player, mtx_back,  
-                                    &s->sphere_back, &manifold[len_front] ),
-   interface_len = len_front + len_back;
+      cmanifold += l;
+      manifold_len += l;
+      manifold_interface += l;
+
+      if( i<=1 )
+         manifold_front ++;
+      else
+         manifold_back ++;
+   }
 
    /* try to slap both wheels onto the ground when landing to prevent mega 
     * angular velocities being added */
-   if( (s->state.activity == k_skate_activity_air) && (len_front != len_back) )
+   if( (s->state.activity == k_skate_activity_air) && 
+       (manifold_front != manifold_back ) )
    {
       v3f trace_from, trace_dir;
       v3_muls( player->rb.to_world[1], -1.0f, trace_dir );
 
-      if( len_front )
-         v3_copy( mtx_back[3],  trace_from );
+      if( manifold_front )
+         v3_copy( (v3f){0.0f,0.0f, k_board_length}, trace_from );
       else
-         v3_copy( mtx_front[3], trace_from );
+         v3_copy( (v3f){0.0f,0.0f,-k_board_length}, trace_from );
+      m4x3_mulv( player->rb.to_world, trace_from, trace_from );
 
       ray_hit ray;
       ray.dist = 0.6f;
 
       if( ray_world( trace_from, trace_dir, &ray ) )
       {
-         rb_ct *ct = &manifold[ interface_len ];
+         rb_ct *ct = cmanifold;
 
          v3_copy( ray.pos, ct->co );
          v3_copy( ray.normal, ct->n );
          ct->p = 0.0f;
 
-         interface_len ++;
+         manifold_len ++;
+         manifold_interface ++;
       }
    }
 
-   interface_manifold = manifold;
-   grind_manifold = manifold + interface_len;
-
-   int grind_len = skate_grind_collide( player, grind_manifold );
+   int grind_len = skate_grind_collide( player, cmanifold );
+   manifold_len += grind_len;
 
-   for( int i=0; i<interface_len+grind_len; i ++ )
+   for( int i=0; i<manifold_len; i ++ )
    {
+#ifdef SKATE_CCD
+      rb_ct *ct = &manifold[i];
+      ct->bias = -0.2f * 
+                  (s->substep_delta * 3600.0f)
+                  * vg_minf( 0.0f, -ct->p+k_penetration_slop );
+      rb_tangent_basis( ct->n, ct->t[0], ct->t[1] );
+      ct->norm_impulse = 0.0f;
+      ct->tangent_impulse[0] = 0.0f;
+      ct->tangent_impulse[1] = 0.0f;
+#else
       rb_prepare_contact( &manifold[i] );
+#endif
       rb_debug_contact( &manifold[i] );
    }
 
-   skate_apply_grind_model( player, grind_manifold, grind_len );
-   skate_apply_interface_model( player, manifold, interface_len );
+   skate_collision_response( player, manifold, manifold_len );
+
+   if( s->substep >= 0.0001f )
+      goto begin_collision;
+
+   skate_apply_grind_model( player, &manifold[manifold_interface], grind_len );
+   skate_apply_interface_model( player, manifold, manifold_interface );
    
    skate_apply_pump_model( player );
    skate_apply_cog_model( player );
-   skate_collision_response( player, manifold, interface_len + grind_len );
 
    skate_apply_grab_model( player );
    skate_apply_friction_model( player );

diff --git a/player_skate.h b/player_skate.h
index 1833062d0bef5939966d2878f461c13cd30031c6..6ace410aa910d08c5d7c3abdc5a7316ae0a43e09 100644 (file)
--- a/player_skate.h
+++ b/player_skate.h
@@ -3,6 +3,8 @@
 
 #include "player_api.h"
 
+#define SKATE_CCD
+
 struct player_skate
 {
    struct
@@ -86,7 +88,6 @@ struct player_skate
                         *anim_push,  *anim_push_reverse,
                         *anim_ollie, *anim_ollie_reverse,
                         *anim_grabs, *anim_stop;
-   rb_sphere sphere_front, sphere_back;
    v3f board_offset,
        board_trick_residualv,
        board_trick_residuald;
@@ -101,6 +102,9 @@ struct player_skate
          blend_jump,
          blend_airdir;
 
+   float substep,
+         substep_delta;
+
    v2f wobble;
 
    float debug_normal_pressure;