X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player.h;h=6c819801b01f664310d73f91144bc1be1911ab92;hb=dfee9022b3513fddec36f7ea70867ee5961a44da;hp=52d658dcde379a446e60d26631182457f8e9ce24;hpb=eb6573694ca9292baaefee233dedb0b79f3ddc2e;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player.h b/player.h
index 52d658d..6c81980 100644
--- a/player.h
+++ b/player.h
@@ -3,6 +3,7 @@
 
 #include "common.h"
 #include "character.h"
+#include "bvh.h"
 
 static int freecam = 0;
 static float k_walkspeed = 2.0f; 
@@ -11,7 +12,7 @@ static int walk_grid_iterations = 1;
 static struct gplayer
 {
    /* Physics */
-   v3f co, v, a, v_last, m, bob;
+   v3f co, v, a, v_last, m, bob, vl;
    v4f rot;
    float vswitch, slip, slip_last,
          reverse;
@@ -30,7 +31,7 @@ static struct gplayer
    v3f land_target_log[22];
    u32 land_target_colours[22];
    int land_log_count;
-   m3x3f vr;
+   m3x3f vr,vr_pstep;
 
    m4x3f to_world, to_local;
    
@@ -46,7 +47,10 @@ static struct gplayer
    v2f angles;
    m4x3f camera, camera_inverse;
 }
-player;
+player = 
+{
+   .on_board = 1
+};
 
 static void player_transform_update(void)
 {
@@ -89,6 +93,7 @@ static void player_mouseview(void)
 
    if( vg_get_button_down( "primary" ) )
       v2_copy( vg_mouse, mouse_last );
+
    else if( vg_get_button( "primary" ) )
    {
       v2f delta;
@@ -98,10 +103,12 @@ static void player_mouseview(void)
       v2_muladds( view_vel, delta, 0.005f, view_vel );
    }
    
+   v2_muladds( view_vel, 
+         (v2f){ vg_get_axis("h1"), vg_get_axis("v1") }, 
+         0.05f, view_vel );
    v2_muls( view_vel, 0.7f, view_vel );
    v2_add( view_vel, player.angles, player.angles );
    player.angles[1] = vg_clampf( player.angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
-
 }
 
 static void player_freecam(void)
@@ -135,6 +142,11 @@ static void apply_gravity( v3f vel, float const timestep )
    v3_muladds( vel, gravity, timestep, vel );
 }
 
+/*
+ * TODO: The angle bias should become greater when launching from a steeper 
+ *       angle and skewed towords more 'downwards' angles when launching from
+ *       shallower trajectories
+ */
 static void player_start_air(void)
 {
    player.in_air = 1;
@@ -144,6 +156,8 @@ static void player_start_air(void)
    float best_velocity_mod = 0.0f,
          best_velocity_delta = -9999.9f;
 
+   float k_bias = 0.97f;
+
    v3f axis, vup;
    m3x3_mulv( player.to_world, (v3f){0.0f,1.0f,0.0f}, vup );
    v3_cross( vup, player.v, axis );
@@ -158,7 +172,7 @@ static void player_start_air(void)
 
       v3f pco, pco1, pv;
       v3_copy( player.co, pco );
-      v3_copy( player.v, pv );
+      v3_muls( player.v, k_bias, pv );
 
       /* 
        * Try different 'rotations' of the velocity to find the best possible
@@ -173,7 +187,7 @@ static void player_start_air(void)
       q_m3x3( vr_q, vr );
 
       m3x3_mulv( vr, pv, pv );
-      v3_muladds( pco, pv, ktimestep, pco );
+      v3_muladds( pco, pv, pstep, pco );
 
       for( int i=0; i<50; i++ )
       {
@@ -208,7 +222,8 @@ static void player_start_air(void)
                best_velocity_mod = vmod;
 
                v3_copy( contact.pos, player.land_target );
-
+               
+               m3x3_copy( vr, player.vr_pstep );
                q_axis_angle( vr_q, axis, vmod*0.1f );
                q_m3x3( vr_q, player.vr );
             }
@@ -353,7 +368,9 @@ static void player_physics_ground(void)
    for( int i=0; i<5; i++ )
    {
       vel[2] = stable_force( vel[2], vg_signf( vel[2] ) * fwd_resistance );
-      vel[0] = stable_force( vel[0], vg_signf( vel[0] ) * -7.0f *substep );
+
+      /* This used to be -7.0 */
+      vel[0] = stable_force( vel[0], vg_signf( vel[0] ) * -10.0f *substep );
    }
    
    static double start_push = 0.0;
@@ -405,9 +422,6 @@ static void draw_cross(v3f pos,u32 colour, float scale)
 static void player_physics_air(void)
 {
    m3x3_mulv( player.vr, player.v, player.v );
-   for( int i=0; i<player.land_log_count; i++ )
-      draw_cross( player.land_target_log[i], player.land_target_colours[i], 1);
-
    draw_cross( player.land_target, 0xff0000ff, 1 );
 
    v3f ground_pos;
@@ -446,6 +460,7 @@ static void player_physics_air(void)
    for( int i=0; i<50; i++ )
    {
       v3_copy( pco, pco1 );
+      m3x3_mulv( player.vr_pstep, pv, pv );
       apply_gravity( pv, pstep );
       v3_muladds( pco, pv, pstep, pco );
 
@@ -490,7 +505,8 @@ static void player_physics_air(void)
    player.iY -= vg_get_axis( "horizontal" ) * 3.6f * ktimestep;
    {
 
-      float iX = vg_get_axis( "vertical" ) * 3.6f * limiter * ktimestep;
+      float iX = vg_get_axis( "vertical" ) * 
+         player.reverse * 3.6f * limiter * ktimestep;
       static float siX = 0.0f;
       siX = vg_lerpf( siX, iX, 0.3f );
       
@@ -544,36 +560,37 @@ static void player_do_motion(void)
 
    player.iY = 0.0f; /* temp */
 
-#if 0
    /* GATE COLLISION */
-   if( gate_intersect( &gate_a, player.co, prevco ) )
+
+   for( int i=0; i<world.gate_count; i++ )
    {
-      teleport_gate *gate = &gate_a;
-
-      m4x3f transport;
-      m4x3_mul( gate->other->to_world, gate->to_local, transport );
-      m4x3_mulv( transport, player.co, player.co );
-      m3x3_mulv( transport, player.v, player.v );
-      m3x3_mulv( transport, player.v_last, player.v_last );
-      m3x3_mulv( transport, player.m, player.m );
-      m3x3_mulv( transport, player.bob, player.bob );
-
-      v4f transport_rotation;
-      m3x3_q( transport, transport_rotation );
-      q_mul( transport_rotation, player.rot, player.rot );
+      teleport_gate *gate = &world.gates[i];
+
+      if( gate_intersect( gate, player.co, prevco ) )
+      {
+         m4x3_mulv( gate->transport, player.co, player.co );
+         m3x3_mulv( gate->transport, player.v, player.v );
+         m3x3_mulv( gate->transport, player.vl, player.vl );
+         m3x3_mulv( gate->transport, player.v_last, player.v_last );
+         m3x3_mulv( gate->transport, player.m, player.m );
+         m3x3_mulv( gate->transport, player.bob, player.bob );
+
+         v4f transport_rotation;
+         m3x3_q( gate->transport, transport_rotation );
+         q_mul( transport_rotation, player.rot, player.rot );
+
+         break;
+      }
    }
-#endif
 
    /* Camera and character */
    player_transform_update();
+   
+   v3_lerp( player.vl, player.v, 0.05f, player.vl );
 
-   player.angles[0] = atan2f( player.v[0], -player.v[2] );
-   player.angles[1] = atan2f( -player.v[1], sqrtf(player.v[0]*player.v[0]+
-                                       player.v[2]*player.v[2]) ) * 0.3f;
-
-   player.air_blend = vg_lerpf( player.air_blend, player.in_air, 0.04f );
-   v3_muladds( player.camera_pos, player.v, -0.05f*player.air_blend, 
-         player.camera_pos );
+   player.angles[0] = atan2f(  player.vl[0], -player.vl[2] );
+   player.angles[1] = atan2f( -player.vl[1], sqrtf(player.vl[0]*player.vl[0]+
+                                            player.vl[2]*player.vl[2]) ) * 0.3f;
 }
 
 static int player_walkgrid_tri_walkable( u32 tri[3] )
@@ -608,10 +625,6 @@ struct walkgrid
    }
    samples[WALKGRID_SIZE][WALKGRID_SIZE];
 
-#if 0
-   u32 geo[256];
-#endif
-
    boxf region;
 
    float move; /* Current amount of movement we have left to apply */
@@ -630,13 +643,9 @@ static void player_walkgrid_samplepole( struct grid_sample *s )
    boxf region = {{ s->pos[0] -0.01f, s->pos[1] - 4.0f, s->pos[2] -0.01f},
                   { s->pos[0] +0.01f, s->pos[1] + 4.0f, s->pos[2] +0.01f}};
 
-#if 0
-   vg_line( region[0],region[1], 0x20ffffff );
-#endif
-
    u32 geo[256];
    v3f tri[3];
-   int len = bvh_select_triangles( &world.geo, region, geo, 256 );
+   int len = bh_select( &world.geo.bhtris, region, geo, 256 );
    
    const float k_minworld_y = -2000.0f;
 
@@ -647,7 +656,7 @@ static void player_walkgrid_samplepole( struct grid_sample *s )
 
    for( int i=0; i<len; i++ )
    {
-      u32 *ptri = &world.geo.indices[ geo[i] ];
+      u32 *ptri = &world.geo.indices[ geo[i]*3 ];
 
       for( int j=0; j<3; j++ )
          v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
@@ -669,18 +678,11 @@ static void player_walkgrid_samplepole( struct grid_sample *s )
             {
                walk_height = p0[1];
             }
-
-#if 0
-            draw_cross( p0, 0xffffffff, 0.05f );
-#endif
          }
          else
          {
             if( p0[1] > block_height )
                block_height = p0[1];
-#if 0
-            draw_cross( p0, 0xff0000ff, 0.05f );
-#endif
          }
       }
    }
@@ -694,39 +696,6 @@ static void player_walkgrid_samplepole( struct grid_sample *s )
          s->type = k_sample_type_valid;
    else
       s->type = k_sample_type_air;
-   
-#if 0
-   if( s->type == k_sample_type_valid )
-   {
-      vg_line_pt3( s->pos, 0.01f, 0xff00ff00 );
-   }
-#endif
-
-#if 0
-   int count = 0;
-
-   ray_hit hit;
-   hit.dist = 10.0f;
-   count = bvh_raycast( &world.geo, sample_pos, vdir, &hit );
-
-   if( count )
-   {
-      v3_copy( hit.pos, s->pos );
-
-      if( !player_walkgrid_tri_walkable( hit.tri ) )
-      {
-         draw_cross( pos, 0xff0000ff, 0.05f );
-         return 0;
-      }
-      else
-      {
-         draw_cross( pos, 0xff00ff00, 0.05f );
-         return count;
-      }
-   }
-   else
-      return 0;
-#endif
 }
 
 float const k_gridscale = 0.5f;
@@ -756,8 +725,7 @@ static void player_walkgrid_clip_blocker( struct grid_sample *sa,
 
    u32 geo[256];
    v3f tri[3];
-   int len = bvh_select_triangles( &world.geo, cell_region, geo, 256 );
-   
+   int len = bh_select( &world.geo.bhtris, cell_region, geo, 256 );
    
    float start_time = v3_length( clipdir ),
          min_time = start_time;
@@ -766,7 +734,7 @@ static void player_walkgrid_clip_blocker( struct grid_sample *sa,
 
    for( int i=0; i<len; i++ )
    {
-      u32 *ptri = &world.geo.indices[ geo[i] ];
+      u32 *ptri = &world.geo.indices[ geo[i]*3 ];
       for( int j=0; j<3; j++ )
          v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
 
@@ -817,7 +785,7 @@ static void player_walkgrid_clip_edge( struct grid_sample *sa,
    v3_muladds( pos, (v3f){1.0f,1.0f,1.0f},  k_gridscale*1.1f, cell_region[1]);
 
    u32 geo[256];
-   int len = bvh_select_triangles( &world.geo, cell_region, geo, 256 );
+   int len = bh_select( &world.geo.bhtris, cell_region, geo, 256 );
 
    float max_dist = 0.0f;
    v3f tri[3];
@@ -827,7 +795,7 @@ static void player_walkgrid_clip_edge( struct grid_sample *sa,
 
    for( int i=0; i<len; i++ )
    {
-      u32 *ptri = &world.geo.indices[ geo[i] ];
+      u32 *ptri = &world.geo.indices[ geo[i]*3 ];
       for( int j=0; j<3; j++ )
          v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
       
@@ -868,29 +836,6 @@ static void player_walkgrid_clip_edge( struct grid_sample *sa,
    }
 }
 
-static void player_walkgrid_clip( struct grid_sample *sa,
-                                  struct grid_sample *sb,
-                                  enum eclipdir dir )
-{
-   int mintype = VG_MIN( sa->type, sb->type ),
-       maxtype = VG_MAX( sa->type, sb->type );
-
-   if( maxtype == k_sample_type_valid )
-   {
-      if( mintype == k_sample_type_air || mintype == k_sample_type_invalid )
-      {
-         player_walkgrid_clip_edge( sa, sb, sa, dir );
-      }
-
-#if 0
-      else if( mintype == k_sample_type_invalid )
-      {
-         player_walkgrid_clip_blocker( sa, sb, dir );
-      }
-#endif
-   }
-}
-
 static const struct conf
 {
    struct confedge
@@ -1024,19 +969,6 @@ static void player_walkgrid_iter(struct walkgrid *wg, int iter)
     * the intersections with the grid, and any edges that are present
     */
 
-#if 0
-   if( wg->cell_id[0] < 0 || wg->cell_id[0] >= WALKGRID_SIZE-1 ||
-       wg->cell_id[1] < 0 || wg->cell_id[1] >= WALKGRID_SIZE-1 )
-   {
-      /*
-       * This condition should never be reached if the grid size is big 
-       * enough
-       */
-      wg->move = -1.0f;
-      return;
-   }
-#endif
-
    u32 icolours[] = { 0xffff00ff, 0xff00ffff, 0xffffff00 };
    
    v3f pa, pb, pc, pd, pl0, pl1;
@@ -1053,6 +985,7 @@ static void player_walkgrid_iter(struct walkgrid *wg, int iter)
    pd[1] = pa[1];
    pd[2] = pa[2];
 #if 0
+   /* if you want to draw the current cell */
    vg_line( pa, pb, 0xff00ffff );
    vg_line( pb, pc, 0xff00ffff );
    vg_line( pc, pd, 0xff00ffff );
@@ -1411,6 +1344,11 @@ static void player_walkgrid_getsurface(void)
          v3_muladds( delta, side, -ktimestep*k_walkspeed, delta );
       if( glfwGetKey( vg_window, GLFW_KEY_D ) )
          v3_muladds( delta, side,  ktimestep*k_walkspeed, delta );
+
+      v3_muladds( delta, fwd, 
+            vg_get_axis("vertical")*-ktimestep*k_walkspeed, delta );
+      v3_muladds( delta, side, 
+            vg_get_axis("horizontal")*ktimestep*k_walkspeed, delta );
    }
 
    /* 
@@ -1432,73 +1370,6 @@ static void player_walkgrid_getsurface(void)
    wg.cell_id[0] = region_cell_pos[0];
    wg.cell_id[1] = region_cell_pos[1];
 
-
-#if 0
-   /* Get surface samples
-    *
-    * TODO: Replace this with a spiral starting from the player position
-    */
-   for( int y=0; y<WALKGRID_SIZE; y++ )
-   {
-      for( int x=0; x<WALKGRID_SIZE; x++ )
-      {
-         struct grid_sample *s = &wg.samples[y][x];
-         v3_muladds( wg.region[0], (v3f){ x, 0, y }, k_gridscale, s->pos );
-         s->pos[1] = cell[1];
-         player_walkgrid_samplepole( s );
-      }
-   }
-   
-   /* 
-    * Calculate h+v clipping distances.
-    * Distances are stored in A always, so you know that if the sample is
-    * invalid, this signifies the start of the manifold as opposed to the
-    * extent or bounds of it.
-    */
-   for( int i=0; i<2; i++ )
-   {
-      for( int x=0; x<WALKGRID_SIZE; x++ )
-      {
-         for( int z=0; z<WALKGRID_SIZE-1; z++ )
-         {
-            struct grid_sample *sa, *sb;
-            if( i == 1 )
-            {
-               sa = &wg.samples[z][x];
-               sb = &wg.samples[z+1][x];
-            }
-            else
-            {
-               sa = &wg.samples[x][z];
-               sb = &wg.samples[x][z+1];
-            }
-            
-            player_walkgrid_clip( sa, sb, i );
-
-            if( sa->type == k_sample_type_valid && 
-                sb->type == k_sample_type_valid )
-               vg_line( sa->pos, sb->pos, 0xffffffff );
-#if 0
-            if( sa->valid != sb->valid )
-            {
-               clipdir[i*2] = (float)(sa->valid - sb->valid) * k_gridscale;
-
-               player_walkgrid_clip( sa->valid? sa->pos: sb->pos,
-                                     clipdir, sa->clip[i] );
-            }
-            else
-            {
-               if( sa->valid )
-               {
-                  vg_line( sa->pos, sb->pos, 0xffffffff );
-               }
-            }
-#endif
-         }
-      }
-   }
-#endif
-   
    for(int y=0; y<WALKGRID_SIZE; y++ )
    {
       for(int x=0; x<WALKGRID_SIZE; x++ )
@@ -1626,13 +1497,6 @@ static void player_walkgrid_getsurface(void)
          break;
    }
 
-#if 0
-   player.co[0] += wg.dir[0];
-   player.co[2] += wg.dir[1];
-#endif
-
-
-
    /* Draw connections */
    struct grid_sample *corners[4];
    for( int x=0; x<WALKGRID_SIZE-1; x++ )
@@ -1719,15 +1583,6 @@ static void player_animate(void)
    v3_muladds( head, offset, 0.7f, head );
    head[1] = vg_clampf( head[1], 0.3f, kheight );
 
-#if 0
-   if( !freecam )
-   {
-      v3_copy( head, player.view );
-      v3f camoffs = {-0.2f,-0.6f,0.00f};
-      v3_add( player.view, camoffs, player.view );
-   }
-#endif
-
    /* 
     * Animation blending
     * ===========================================
@@ -1757,10 +1612,14 @@ static void player_animate(void)
          amt_aero = amt_std * (1.0f-fstand),
          amt_slide = amt_ground * fslide;
 
-   character_final_pose( &player.mdl, offset, &pose_stand, amt_stand );
+   character_final_pose( &player.mdl, offset, &pose_stand, amt_stand*fdirz );
+   character_final_pose( &player.mdl, offset, 
+         &pose_stand_reverse, amt_stand * (1.0f-fdirz) );
+
    character_final_pose( &player.mdl, offset, &pose_aero, amt_aero*fdirz );
    character_final_pose( &player.mdl, offset, 
          &pose_aero_reverse, amt_aero * (1.0f-fdirz) );
+
    character_final_pose( &player.mdl, offset, &pose_slide, amt_slide*fdirx );
    character_final_pose( &player.mdl, offset, 
          &pose_slide1, amt_slide*(1.0f-fdirx) );
@@ -1775,6 +1634,10 @@ static void player_animate(void)
    player.camera_pos[1] = vg_clampf( player.camera_pos[1], 0.3f, kheight );
    m4x3_mulv( player.to_world, player.camera_pos, player.camera_pos );
 
+   player.air_blend = vg_lerpf( player.air_blend, player.in_air, 0.04f );
+   v3_muladds( player.camera_pos, player.v, -0.05f*player.air_blend, 
+         player.camera_pos );
+
    /* 
     * Additive effects
     * ==========================
@@ -1874,11 +1737,290 @@ static void player_animate(void)
    player.mdl.rhead = rhead;
 }
 
+static int giftwrapXZ( v3f *points, int *output, int len )
+{
+   int l, p, q, count;
+
+   if( len < 3 )
+      return 0;
+
+   l = 0;
+   for( int i=1; i<len; i++ )
+      if( points[i][0] < points[l][0] )
+         l = i;
+
+   p = l;
+   count = 0;
+   do
+   {
+      if( count >= len )
+      {
+         vg_error ("MANIFOLD ERR (%d)\n", count );
+         return 0;
+      }
+      output[ count ++ ] = p;
+
+      q = (p+1)%len;
+
+      for( int i=0; i<len; i++ )
+      {
+         float orient = 
+             (points[i][2]-points[p][2])*(points[q][0]-points[i][0]) -
+             (points[i][0]-points[p][0])*(points[q][2]-points[i][2]);
+
+         if( orient > 0.0001f )
+         {
+            q = i;
+         }
+      }
+      p = q;
+   }
+   while( p != l );
+   
+   return count;
+}
+ 
+static void player_do_collision( rigidbody *rb )
+{
+   /*
+    * If point is inside box
+    *   find normal (theres 8 simple pyramid regions for this, x>y/dim .. etc)
+    *   find distance (same sorta thing)
+    *
+    * apply normal impulse to rotation
+    * correct position based on new penetration amount if needed
+    * apply normal impulse to velocity
+    */
+
+   v3f pfront, pback;
+   m4x3_mulv( player.to_world, (v3f){ 0.0f,0.0f,-1.0f }, pfront );
+   m4x3_mulv( player.to_world, (v3f){ 0.0f,0.0f, 1.0f }, pback );
+
+   float const kheight = 2.0f;
+   
+   v3f verts[8];
+
+   v3f a, b;
+   v3_copy( rb->bbx[0], a );
+   v3_copy( rb->bbx[1], b );
+
+   m4x3f compound;
+   m4x3_mul( player.to_local, rb->to_world, compound );
+   
+	m4x3_mulv( compound, (v3f){ a[0], a[1], a[2] }, verts[0] );
+	m4x3_mulv( compound, (v3f){ a[0], b[1], a[2] }, verts[1] );
+	m4x3_mulv( compound, (v3f){ b[0], b[1], a[2] }, verts[2] );
+	m4x3_mulv( compound, (v3f){ b[0], a[1], a[2] }, verts[3] );
+	m4x3_mulv( compound, (v3f){ a[0], a[1], b[2] }, verts[4] );
+	m4x3_mulv( compound, (v3f){ a[0], b[1], b[2] }, verts[5] );
+	m4x3_mulv( compound, (v3f){ b[0], b[1], b[2] }, verts[6] );
+	m4x3_mulv( compound, (v3f){ b[0], a[1], b[2] }, verts[7] );
+
+   int const indices[12][2] = {
+      {0,1},{1,2},{2,3},{3,0},{4,5},{5,6},{6,7},{7,4},
+      {0,4},{1,5},{2,6},{3,7}
+   };
+   
+   v3f hull[12*2 + 8];
+   int hull_indices[12*2 + 8];
+   int hull_len = 0;
+
+   for( int i=0; i<8; i++ )
+   {
+      int ia = indices[i][0];
+      float ya = verts[ia][1];
+
+      if( ya > 0.2f && ya < kheight )
+      {
+         int add_point = 1;
+         for( int j=0; j<hull_len; j++ )
+         {
+            v2f delta = { verts[ia][0]-hull[j][0], verts[ia][2]-hull[j][2] };
+            if( v2_length2( delta ) < 0.0004f )
+            {
+               add_point = 0;
+               break;
+            }
+         }
+
+         if( add_point )
+            v3_copy( verts[ia], hull[hull_len] );
+
+         hull[hull_len ++][1] = 0.2f;
+      }
+   }
+
+   for( int i=0; i<vg_list_size(indices); i++ )
+   {
+      int ia = indices[i][0],
+          ib = indices[i][1];
+
+      v3f p0, p1;
+
+      float ya = verts[ia][1],
+            yb = verts[ib][1],
+            d = 1.0f/(yb-ya),
+            qa;
+
+      float planes[] = { 0.2f, kheight };
+      
+      for( int k=0; k<vg_list_size(planes); k++ )
+      {
+         float clip = planes[k];
+
+         if( (ya-clip) * (yb-clip) < 0.0f )
+         {
+            v3_muls( verts[ia], (yb-clip)*d, p0 );
+            v3_muladds( p0, verts[ib], -(ya-clip)*d, p0 );
+            
+            int add_point = 1;
+            for( int j=0; j<hull_len; j++ )
+            {
+               v2f delta = { p0[0]-hull[j][0], p0[2]-hull[j][2] };
+               if( v2_length2( delta ) < 0.0004f )
+               {
+                  add_point = 0;
+                  break;
+               }
+            }
+
+            if( add_point )
+               v3_copy( p0, hull[hull_len ++] );
+
+            m4x3_mulv( player.to_world, p0, p0 );
+            vg_line_pt3( p0, 0.1f, 0xffffff00 );
+         }
+      }
+   }
+
+   if( hull_len < 3 ) 
+      return;
+
+   int len = giftwrapXZ( hull, hull_indices, hull_len );
+   for( int i=0; i<len; i++ )
+   {
+      v3f p0, p1, p2, p3;
+      v3_copy( hull[hull_indices[i]], p0 );
+      v3_copy( hull[hull_indices[(i+1)%len]], p1 );
+      p0[1] = 0.2f;
+      p1[1] = 0.2f;
+      v3_add( p0, (v3f){0,kheight-0.2f,0}, p2 );
+      v3_add( p1, (v3f){0,kheight-0.2f,0}, p3 );
+         
+      m4x3_mulv( player.to_world, p0, p0 );
+      m4x3_mulv( player.to_world, p1, p1 );
+      m4x3_mulv( player.to_world, p2, p2 );
+      m4x3_mulv( player.to_world, p3, p3 );
+
+      vg_line2( p0, p1, 0xff00ffff, 0xff000000 );
+      vg_line( p2, p3, 0xff00ffff );
+      vg_line( p0, p2, 0xff00ffa0 );
+   }
+
+   v2f endpoints[] = {{ 0.0f, -1.0f },{ 0.0f, 1.0f }};
+   
+   for( int j=0; j<vg_list_size(endpoints); j++ )
+   {
+      v2f point;
+      v2_copy( endpoints[j], point );
+
+      int collide = 1;
+      float min_dist = 99999.9f;
+      v2f normal = {0.0f,0.0f};
+      for( int i=0; i<len; i++ )
+      {
+         v2f p0, p1;
+         p0[0] = hull[hull_indices[i]][0];
+         p0[1] = hull[hull_indices[i]][2];
+         p1[0] = hull[hull_indices[(i+1)%len]][0];
+         p1[1] = hull[hull_indices[(i+1)%len]][2];
+         
+         v2f t,n, rel;
+         v2_sub( p1, p0, t );
+         n[0] = -t[1];
+         n[1] =  t[0];
+         v2_normalize(n);
+         
+         v2_sub( point, p0, rel );
+         float d = -v2_dot( n, rel ) + 0.5f;
+
+         if( d < 0.0f )
+         {
+            collide = 0;
+            break;
+         }
+
+         if( d < min_dist )
+         {
+            min_dist = d;
+            v2_copy( n, normal );
+         }
+      }
+
+      if( collide )
+      {
+         v3f p0, p1;
+         p0[0] =  0.0f;
+         p0[1] =  0.2f;
+         p0[2] = -1.0f;
+
+         p1[0] = p0[0] + normal[0]*min_dist;
+         p1[1] = p0[1];
+         p1[2] = p0[2] + normal[1]*min_dist;
+         
+         m4x3_mulv( player.to_world, p0, p0 );
+         m4x3_mulv( player.to_world, p1, p1 );
+
+         vg_line( p0, p1, 0xffffffff );
+         
+         v3f vel;
+         m3x3_mulv( player.to_local, player.v, vel );
+         vel[1] = vel[2];
+
+         float vn = vg_maxf( -v2_dot( vel, normal ), 0.0f );
+         vn += -0.2f * (1.0f/k_rb_delta) * vg_minf( 0.0f, -min_dist+0.04f );
+         
+         v2f impulse;
+         if( vn > 14.0f )
+         {
+            player.is_dead = 1;
+            character_ragdoll_copypose( &player.mdl, player.v );
+            return;
+         }
+
+         if( vn > 0.0f )
+         {
+            v2_muls( normal, min_dist, impulse );
+            float rotation = v2_cross( point, impulse )*0.08f;
+            v4f rot;
+            v3f up = {0.0f,1.0f,0.0f};
+            m3x3_mulv( player.to_world, up, up );
+            q_axis_angle( rot, up, -rotation );
+            q_mul( rot, player.rot, player.rot );
+         }
+
+         v2_muls( normal, vn*0.03f, impulse );
+         v3f impulse_world = { impulse[0], 0.0f, impulse[1] };
+
+         m3x3_mulv( player.to_world, impulse_world, impulse_world );
+         v3_add( impulse_world, player.v, player.v );
+      }
+   }
+}
+
 static void player_update(void)
 {
+   for( int i=0; i<player.land_log_count; i++ )
+      draw_cross( player.land_target_log[i], player.land_target_colours[i], 1);
+
    if( vg_get_axis("grabl")>0.0f)
       reset_player(0,NULL);
 
+   if( vg_get_button_down( "switchmode" ) )
+   {
+      player.on_board ^= 0x1;
+   }
+
    if( freecam )
    {
       player_freecam();
@@ -1887,13 +2029,58 @@ static void player_update(void)
    {
       if( player.is_dead )
       {
+         /* 
+          * Follow camera
+          */
          character_ragdoll_iter( &player.mdl );
          character_debug_ragdoll( &player.mdl );
+
+         v3f delta;
+         v3f head_pos;
+         v3_copy( player.mdl.ragdoll[k_chpart_head].co, head_pos );
+
+         v3_sub( head_pos, player.camera_pos, delta );
+         v3_normalize( delta );
+
+         v3f follow_pos;
+         v3_muladds( head_pos, delta, -2.5f, follow_pos );
+         v3_lerp( player.camera_pos, follow_pos, 0.1f, player.camera_pos );
+
+         /* 
+          * Make sure the camera stays above the ground
+          */
+         v3f min_height = {0.0f,1.0f,0.0f};
+
+         v3f sample;
+         v3_add( player.camera_pos, min_height, sample );
+         ray_hit hit;
+         hit.dist = min_height[1]*2.0f;
+
+         if( ray_world( sample, (v3f){0.0f,-1.0f,0.0f}, &hit ))
+            v3_add( hit.pos, min_height, player.camera_pos );
+
+         player.camera_pos[1] = 
+            vg_maxf( wrender.height + 2.0f, player.camera_pos[1] );
+
+         player.angles[0] = atan2f( delta[0], -delta[2] ); 
+         player.angles[1] = -asinf( delta[1] );
       }
       else
       {
          if( player.on_board )
          {
+            bh_debug_node(&world.bhcubes, 0, 
+                  player.camera_pos, 0xff80ff00 );
+
+            u32 colliders[16];
+            boxf wbox = {{ -2.0f, -2.0f, -2.0f },
+                         {  2.0f,  2.0f,  2.0f }};
+            m4x3_transform_aabb( player.to_world, wbox );
+            int len = bh_select( &world.bhcubes, wbox, colliders, 32 );
+
+            for( int i=0; i<len; i++ )
+               player_do_collision( &world.temp_rbs[colliders[i]] );
+
             player_do_motion();
             player_animate();
          }