static int freecam = 0;
static float k_walkspeed = 2.0f;
+static int walk_grid_iterations = 1;
static struct gplayer
{
static int reset_player( int argc, char const *argv[] )
{
- v3_zero( player.co );
+ v3_copy( (v3f){ 0.0f, -2.0f, 0.0f }, player.co );
if( argc == 1 )
{
}
/* Prediction
- *
- * TODO: Find best landing surface and guide player towords it
*/
float pstep = ktimestep*10.0f;
player.camera_pos );
}
+static int player_walkgrid_tri_walkable( u32 tri[3] )
+{
+ return tri[0] < world.sm_road.vertex_count;
+}
+
+#define WALKGRID_SIZE 16
+struct walkgrid
+{
+ struct grid_sample
+ {
+ enum sample_type
+ {
+ k_sample_type_air, /* Nothing was hit. */
+ k_sample_type_invalid, /* The point is invalid, but there is a sample
+ underneath that can be used */
+ k_sample_type_valid, /* This point is good */
+ }
+ type;
+
+ v3f clip[2];
+ v3f pos;
+
+ enum traverse_state
+ {
+ k_traverse_none = 0x00,
+ k_traverse_h = 0x01,
+ k_traverse_v = 0x02
+ }
+ state;
+ }
+ samples[WALKGRID_SIZE][WALKGRID_SIZE];
+
+#if 0
+ u32 geo[256];
+#endif
+
+ boxf region;
+
+ float move; /* Current amount of movement we have left to apply */
+ v2f dir; /* The movement delta */
+ v2i cell_id;/* Current cell */
+ v2f pos; /* Local position (in cell) */
+ float h;
+};
+
/*
* Get a sample at this pole location, will return 1 if the sample is valid,
* and pos will be updated to be the intersection location.
*/
-static int player_walkgrid_samplepole( u32 *geo, int len, v3f pos )
+static void player_walkgrid_samplepole( struct grid_sample *s )
{
- v3f p1;
- v3_copy( pos, p1 );
- p1[1] -= 10.0f;
+ 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}};
- vg_line( pos, p1, 0x20ffffff );
+#if 0
+ vg_line( region[0],region[1], 0x20ffffff );
+#endif
- v3f sample_pos;
- v3_copy(pos, sample_pos);
+ u32 geo[256];
+ v3f tri[3];
+ int len = bvh_select_triangles( &world.geo, region, geo, 256 );
+
+ const float k_minworld_y = -2000.0f;
- v3f vdir = {0.0f,-1.0f,0.0f};
- int count = 0;
+ float walk_height = k_minworld_y,
+ block_height = k_minworld_y;
+
+ s->type = k_sample_type_air;
- ray_hit hit;
- hit.dist = INFINITY;
for( int i=0; i<len; i++ )
{
- u32 *tri = &world.geo.indices[ geo[i] ];
- count += bvh_ray_tri( &world.geo, tri, sample_pos, vdir, &hit );
+ u32 *ptri = &world.geo.indices[ geo[i] ];
+
+ for( int j=0; j<3; j++ )
+ v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
+
+ v3f vdown = {0.0f,-1.0f,0.0f};
+ v3f sample_from;
+ v3_copy( s->pos, sample_from );
+ sample_from[1] = region[1][1];
+
+ float dist;
+ if( ray_tri( tri, sample_from, vdown, &dist ))
+ {
+ v3f p0;
+ v3_muladds( sample_from, vdown, dist, p0 );
+
+ if( player_walkgrid_tri_walkable(ptri) )
+ {
+ if( p0[1] > walk_height )
+ {
+ 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
+ }
+ }
+ }
+
+ s->pos[1] = walk_height;
+
+ if( walk_height > k_minworld_y )
+ if( block_height > walk_height )
+ s->type = k_sample_type_invalid;
+ else
+ 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 )
{
- v3f v0, v1;
- float *pa = world.geo.verts[hit.tri[0]].co,
- *pb = world.geo.verts[hit.tri[1]].co,
- *pc = world.geo.verts[hit.tri[2]].co;
-
- v3_sub( pa, pb, v0 );
- v3_sub( pc, pb, v1 );
- v3_cross( v1, v0, hit.normal );
- v3_normalize( hit.normal );
- v3_muladds( sample_pos, vdir, hit.dist, pos );
-
- draw_cross( pos, 0xff00ff00, 0.05f );
- return 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;
+
+enum eclipdir
+{
+ k_eclipdir_h = 0,
+ k_eclipdir_v = 1
+};
+
+static void player_walkgrid_clip_blocker( struct grid_sample *sa,
+ struct grid_sample *sb,
+ struct grid_sample *st,
+ enum eclipdir dir )
+{
+ v3f clipdir, pos;
+ int valid_a = sa->type == k_sample_type_valid,
+ valid_b = sb->type == k_sample_type_valid;
+ struct grid_sample *target = valid_a? sa: sb,
+ *other = valid_a? sb: sa;
+ v3_copy( target->pos, pos );
+ v3_sub( other->pos, target->pos, clipdir );
+
+ boxf cell_region;
+ v3_muladds( pos, (v3f){1.0f,1.0f,1.0f}, -k_gridscale*2.1f, cell_region[0]);
+ v3_muladds( pos, (v3f){1.0f,1.0f,1.0f}, k_gridscale*2.1f, cell_region[1]);
+
+ u32 geo[256];
+ v3f tri[3];
+ int len = bvh_select_triangles( &world.geo, cell_region, geo, 256 );
+
+
+ float start_time = v3_length( clipdir ),
+ min_time = start_time;
+ v3_normalize( clipdir );
+ v3_muls( clipdir, 0.0001f, st->clip[dir] );
+
+ for( int i=0; i<len; i++ )
+ {
+ u32 *ptri = &world.geo.indices[ geo[i] ];
+ for( int j=0; j<3; j++ )
+ v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
+
+ if( player_walkgrid_tri_walkable(ptri) )
+ continue;
+
+ float dist;
+ if(ray_tri( tri, pos, clipdir, &dist ))
+ {
+ if( dist > 0.0f && dist < min_time )
+ {
+ min_time = dist;
+ sb->type = k_sample_type_air;
+ }
+ }
+ }
+
+ if( !(min_time < start_time) )
+ min_time = 0.5f * k_gridscale;
+
+ v3_muls( clipdir, min_time/k_gridscale, st->clip[dir] );
+
+ v3f p0;
+ v3_muladds( target->pos, st->clip[dir], k_gridscale, p0 );
}
-static void player_walkgrid_clip(u32 *geo, int len, v3f pos, v3f dir, v3f clip)
+static void player_walkgrid_clip_edge( struct grid_sample *sa,
+ struct grid_sample *sb,
+ struct grid_sample *st, /* data store */
+ enum eclipdir dir )
{
+ v3f clipdir = { 0.0f, 0.0f, 0.0f }, pos;
+ int valid_a = sa->type == k_sample_type_valid,
+ valid_b = sb->type == k_sample_type_valid;
+
+ struct grid_sample *target = valid_a? sa: sb,
+ *other = valid_a? sb: sa;
+
+ v3_sub( other->pos, target->pos, clipdir );
+ clipdir[1] = 0.0f;
+
+ v3_copy( target->pos, pos );
+
+ boxf cell_region;
+ v3_muladds( pos, (v3f){1.0f,1.0f,1.0f}, -k_gridscale*1.1f, cell_region[0]);
+ 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 );
+
float max_dist = 0.0f;
v3f tri[3];
v3f perp;
- v3_cross( dir,(v3f){0.0f,1.0f,0.0f},perp );
- v3_copy( pos, clip );
+ v3_cross( clipdir,(v3f){0.0f,1.0f,0.0f},perp );
+ v3_muls( clipdir, 0.001f, st->clip[dir] );
for( int i=0; i<len; i++ )
{
u32 *ptri = &world.geo.indices[ geo[i] ];
for( int j=0; j<3; j++ )
v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
+
+ if( !player_walkgrid_tri_walkable(ptri) )
+ continue;
for( int k=0; k<3; k++ )
{
v3_sub( tri[ia], pos, v0 );
v3_sub( tri[ib], pos, v1 );
- if( (dir[2]*v0[0] - dir[0]*v0[2]) *
- (dir[2]*v1[0] - dir[0]*v1[2]) < 0.0f )
+ if( (clipdir[2]*v0[0] - clipdir[0]*v0[2]) *
+ (clipdir[2]*v1[0] - clipdir[0]*v1[2]) < 0.0f )
{
float da = v3_dot(v0,perp),
db = v3_dot(v1,perp),
v3_muls( v1, qa, p0 );
v3_muladds( p0, v0, 1.0f-qa, p0 );
- float h = v3_dot(p0,dir)/v3_dot(dir,dir);
+ float h = v3_dot(p0,clipdir)/v3_dot(clipdir,clipdir);
if( h >= max_dist && h <= 1.0f )
{
max_dist = h;
- float l = 1.0f/v3_length(dir);
- v3_muls( p0, l, clip );
+ float l = 1.0f/v3_length(clipdir);
+ v3_muls( p0, l, st->clip[dir] );
}
}
}
}
}
-#define WALKGRID_SIZE 8
-struct walkgrid
+static void player_walkgrid_clip( struct grid_sample *sa,
+ struct grid_sample *sb,
+ enum eclipdir dir )
{
- struct grid_sample
- {
- int valid;
- v3f clip[2];
- v3f pos;
- }
- samples[WALKGRID_SIZE][WALKGRID_SIZE];
- u32 geo[256];
+ int mintype = VG_MIN( sa->type, sb->type ),
+ maxtype = VG_MAX( sa->type, sb->type );
- boxf region;
+ 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 );
+ }
- float move; /* Current amount of movement we have left to apply */
- v2f dir; /* The movement delta */
- v2i cell_id;/* Current cell */
- v2f pos; /* Local position (in cell) */
- float h;
-};
+#if 0
+ else if( mintype == k_sample_type_invalid )
+ {
+ player_walkgrid_clip_blocker( sa, sb, dir );
+ }
+#endif
+ }
+}
static const struct conf
{
* a: axis index
* o: the 'other' point to do a A/B test with
* if its -1, all AB is done.
- *
- * TODO: Check the major edge against point (for the double cases)
*/
int i0, i1,
d0, d1,
corners[2] = &wg->samples[cell[1]+1][cell[0]+1];
corners[3] = &wg->samples[cell[1] ][cell[0]+1];
- u32 config = (corners[0]->valid<<3) | (corners[1]->valid<<2) |
- (corners[2]->valid<<1) | corners[3]->valid;
+ u32 vd0 = corners[0]->type == k_sample_type_valid,
+ vd1 = corners[1]->type == k_sample_type_valid,
+ vd2 = corners[2]->type == k_sample_type_valid,
+ vd3 = corners[3]->type == k_sample_type_valid,
+ config = (vd0<<3) | (vd1<<2) | (vd2<<1) | vd3;
return &k_walkgrid_configs[ config ];
}
-float const k_gridscale = 0.5f;
-
static void player_walkgrid_floor(v3f pos)
{
v3_muls( pos, 1.0f/k_gridscale, pos );
v3f world;
world[0] = wg->region[0][0]+((float)wg->cell_id[0]+wg->pos[0])*k_gridscale;
+ world[1] = player.co[1];
world[2] = wg->region[0][2]+((float)wg->cell_id[1]+wg->pos[1])*k_gridscale;
struct grid_sample *corners[4];
float const k_height = 1.78f;
float const k_region_size = (float)WALKGRID_SIZE/2.0f * k_gridscale;
- struct walkgrid wg;
+ static struct walkgrid wg;
v3f cell;
v3_copy( player.co, cell );
v3_muladds( cell, (v3f){-1.0f,-1.0f,-1.0f}, k_region_size, wg.region[0] );
v3_muladds( cell, (v3f){ 1.0f, 1.0f, 1.0f}, k_region_size, wg.region[1] );
- int tri_count = bvh_select_triangles( &world.geo, wg.region, wg.geo, 256 );
+
+ /*
+ * Create player input vector
+ */
+ v3f delta = {0.0f,0.0f,0.0f};
+ v3f fwd = { -sinf(-player.angles[0]), 0.0f, -cosf(-player.angles[0]) },
+ side = { -fwd[2], 0.0f, fwd[0] };
- v3f tri[3];
- for( int i=0; i<tri_count; i++ )
+ /* Temp */
+ if( !vg_console_enabled() )
{
- for( int j=0; j<3; j++ )
- v3_copy( world.geo.verts[ world.geo.indices[wg.geo[i]+j]].co, tri[j] );
+ if( glfwGetKey( vg_window, GLFW_KEY_W ) )
+ v3_muladds( delta, fwd, ktimestep*k_walkspeed, delta );
+ if( glfwGetKey( vg_window, GLFW_KEY_S ) )
+ v3_muladds( delta, fwd, -ktimestep*k_walkspeed, delta );
- vg_line( tri[0], tri[1], 0xffa2ff30 );
- vg_line( tri[1], tri[2], 0xffa2ff30 );
- vg_line( tri[2], tri[0], 0xffa2ff30 );
+ if( glfwGetKey( vg_window, GLFW_KEY_A ) )
+ v3_muladds( delta, side, -ktimestep*k_walkspeed, delta );
+ if( glfwGetKey( vg_window, GLFW_KEY_D ) )
+ v3_muladds( delta, side, ktimestep*k_walkspeed, delta );
}
+ /*
+ * Create our move in grid space
+ */
+ wg.dir[0] = delta[0] * (1.0f/k_gridscale);
+ wg.dir[1] = delta[2] * (1.0f/k_gridscale);
+ wg.move = 1.0f;
+
+ v2f region_pos =
+ {
+ (player.co[0] - wg.region[0][0]) * (1.0f/k_gridscale),
+ (player.co[2] - wg.region[0][2]) * (1.0f/k_gridscale)
+ };
+ v2f region_cell_pos;
+ v2_floor( region_pos, region_cell_pos );
+ v2_sub( region_pos, region_cell_pos, wg.pos );
+
+ 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
{
struct grid_sample *s = &wg.samples[y][x];
v3_muladds( wg.region[0], (v3f){ x, 0, y }, k_gridscale, s->pos );
- s->pos[1] = player.co[1] + k_height;
-
- s->valid = player_walkgrid_samplepole( wg.geo,tri_count,s->pos )? 1: 0;
+ s->pos[1] = cell[1];
+ player_walkgrid_samplepole( s );
}
}
{
for( int z=0; z<WALKGRID_SIZE-1; z++ )
{
- v3f clipdir = { 0.0f, 0.0f, 0.0f };
-
struct grid_sample *sa, *sb;
if( i == 1 )
{
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( wg.geo, tri_count,
- sa->valid? sa->pos: sb->pos,
- clipdir, sa->clip[i] );
+
+ player_walkgrid_clip( sa->valid? sa->pos: sb->pos,
+ clipdir, sa->clip[i] );
}
else
{
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++ )
+ {
+ struct grid_sample *s = &wg.samples[y][x];
+ v3_muladds( wg.region[0], (v3f){ x, 0, y }, k_gridscale, s->pos );
+ s->state = k_traverse_none;
+ s->type = k_sample_type_air;
+ v3_zero( s->clip[0] );
+ v3_zero( s->clip[1] );
+ }
+ }
+
+ v2i border[WALKGRID_SIZE*WALKGRID_SIZE];
+ v2i *cborder = border;
+ u32 border_length = 1;
+
+ struct grid_sample *base = NULL;
+
+ v2i starters[] = {{0,0},{1,1},{0,1},{1,0}};
+
+ for( int i=0;i<4;i++ )
+ {
+ v2i test;
+ v2i_add( wg.cell_id, starters[i], test );
+ v2i_copy( test, border[0] );
+ base = &wg.samples[test[1]][test[0]];
+
+ base->pos[1] = cell[1];
+ player_walkgrid_samplepole( base );
+
+ if( base->type == k_sample_type_valid )
+ break;
+ else
+ base->type = k_sample_type_air;
+ }
+
+ vg_line_pt3( base->pos, 0.1f, 0xffffffff );
+
+ int iter = 0;
+
+ while( border_length )
+ {
+ v2i directions[] = {{1,0},{0,1},{-1,0},{0,-1}};
+
+ v2i *old_border = cborder;
+ int len = border_length;
+
+ border_length = 0;
+ cborder = old_border+len;
+
+ for( int i=0; i<len; i++ )
+ {
+ v2i co;
+ v2i_copy( old_border[i], co );
+ struct grid_sample *sa = &wg.samples[co[1]][co[0]];
+
+ for( int j=0; j<4; j++ )
+ {
+ v2i newp;
+ v2i_add( co, directions[j], newp );
+
+ if( newp[0] < 0 || newp[1] < 0 ||
+ newp[0] == WALKGRID_SIZE || newp[1] == WALKGRID_SIZE )
+ continue;
+
+ struct grid_sample *sb = &wg.samples[newp[1]][newp[0]];
+ enum traverse_state thismove = j%2==0? 1: 2;
+
+ if( (sb->state & thismove) == 0x00 ||
+ sb->type == k_sample_type_air )
+ {
+ sb->pos[1] = sa->pos[1];
+
+ player_walkgrid_samplepole( sb );
+
+ if( sb->type != k_sample_type_air )
+ {
+ /*
+ * Need to do a blocker pass
+ */
+
+ struct grid_sample *store = (j>>1 == 0)? sa: sb;
+ player_walkgrid_clip_blocker( sa, sb, store, j%2 );
+
+
+ if( sb->type != k_sample_type_air )
+ {
+ vg_line( sa->pos, sb->pos, 0xffffffff );
+
+ if( sb->state == k_traverse_none )
+ v2i_copy( newp, cborder[ border_length ++ ] );
+ }
+ else
+ {
+ v3f p1;
+ v3_muladds( sa->pos, store->clip[j%2], k_gridscale, p1 );
+ vg_line( sa->pos, p1, 0xffffffff );
+ }
+ }
+ else
+ {
+ /*
+ * A clipping pass is now done on the edge of the walkable
+ * surface
+ */
+
+ struct grid_sample *store = (j>>1 == 0)? sa: sb;
+ player_walkgrid_clip_edge( sa, sb, store, j%2 );
+
+ v3f p1;
+ v3_muladds( sa->pos, store->clip[j%2], k_gridscale, p1 );
+ vg_line( sa->pos, p1, 0xffffffff );
+ }
+
+ sb->state |= thismove;
+ }
}
+
+ sa->state = k_traverse_h|k_traverse_v;
}
+
+ iter ++;
+ if( iter == walk_grid_iterations )
+ 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++ )
corners[edge->d0]->clip[edge->a0], k_gridscale, p0 );
v3_muladds( corners[edge->i1]->pos,
corners[edge->d1]->clip[edge->a1], k_gridscale, p1 );
- vg_line( p0, p1, 0xff0000ff );
- vg_line( corners[edge->i0]->pos, p0, 0xffffffff );
- vg_line( corners[edge->i1]->pos, p1, 0xffffffff );
+ vg_line( p0, p1, 0xff0000ff );
}
}
}
* Commit player movement into the grid
*/
- v3f delta = {0.0f,0.0f,0.0f};
- v3f fwd = { -sinf(-player.angles[0]), 0.0f, -cosf(-player.angles[0]) },
- side = { -fwd[2], 0.0f, fwd[0] };
-
- /* Temp */
- if( !vg_console_enabled() )
- {
- if( glfwGetKey( vg_window, GLFW_KEY_W ) )
- v3_muladds( delta, fwd, ktimestep*k_walkspeed, delta );
- if( glfwGetKey( vg_window, GLFW_KEY_S ) )
- v3_muladds( delta, fwd, -ktimestep*k_walkspeed, delta );
-
- if( glfwGetKey( vg_window, GLFW_KEY_A ) )
- v3_muladds( delta, side, -ktimestep*k_walkspeed, delta );
- if( glfwGetKey( vg_window, GLFW_KEY_D ) )
- v3_muladds( delta, side, ktimestep*k_walkspeed, delta );
- }
-
if( v3_length2(delta) <= 0.00001f )
return;
- /*
- * Create our move in grid space
- */
- wg.dir[0] = delta[0] * (1.0f/k_gridscale);
- wg.dir[1] = delta[2] * (1.0f/k_gridscale);
- wg.move = 1.0f;
-
- v2f region_pos =
- {
- (player.co[0] - wg.region[0][0]) * (1.0f/k_gridscale),
- (player.co[2] - wg.region[0][2]) * (1.0f/k_gridscale)
- };
- v2f region_cell_pos;
- v2_floor( region_pos, region_cell_pos );
- v2_sub( region_pos, region_cell_pos, wg.pos );
-
- wg.cell_id[0] = region_cell_pos[0];
- wg.cell_id[1] = region_cell_pos[1];
-
int i=0;
for(; i<8 && wg.move > 0.001f; i++ )
player_walkgrid_iter( &wg, i );
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff