#include "character.h"
static int freecam = 0;
+static float k_walkspeed = 2.0f;
static struct gplayer
{
v3f p0;
v3_muls( v1, qa, p0 );
v3_muladds( p0, v0, 1.0f-qa, p0 );
-
+
float h = v3_dot(p0,dir)/v3_dot(dir,dir);
if( h >= max_dist && h <= 1.0f )
{
max_dist = h;
- v3_copy( p0, clip );
+ float l = 1.0f/v3_length(dir);
+ v3_muls( p0, l, clip );
}
}
}
}
+}
+
+#define WALKGRID_SIZE 8
+struct walkgrid
+{
+ struct grid_sample
+ {
+ int valid;
+ v3f clip[2];
+ v3f pos;
+ }
+ samples[WALKGRID_SIZE][WALKGRID_SIZE];
+ u32 geo[256];
+
+ 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;
+};
+
+static const struct conf
+{
+ struct confedge
+ {
+ /* i: sample index
+ * d: data index
+ * 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,
+ a0, a1,
+ o0, o1;
+ }
+ edges[2];
+ int edge_count;
+}
+k_walkgrid_configs[16] = {
+ {{},0},
+ {{{ 3,3, 3,0, 1,0, -1,-1 }}, 1},
+ {{{ 2,2, 1,3, 0,1, -1,-1 }}, 1},
+ {{{ 2,3, 1,0, 0,0, 3,-1 }}, 1},
+
+ {{{ 1,1, 0,1, 1,0, -1,-1 }}, 1},
+ {{{ 3,3, 3,0, 1,0, -1,-1 },
+ { 1,1, 0,1, 1,0, -1,-1 }}, 2},
+ {{{ 1,2, 0,3, 1,1, 2,-1 }}, 1},
+ {{{ 1,3, 0,0, 1,0, 2, 2 }}, 1},
+
+ {{{ 0,0, 0,0, 0,1, -1,-1 }}, 1},
+ {{{ 3,0, 3,0, 1,1, 0,-1 }}, 1},
+ {{{ 2,2, 1,3, 0,1, -1,-1 },
+ { 0,0, 0,0, 0,1, -1,-1 }}, 2},
+ {{{ 2,0, 1,0, 0,1, 3, 3 }}, 1},
+
+ {{{ 0,1, 0,1, 0,0, 1,-1 }}, 1},
+ {{{ 3,1, 3,1, 1,0, 0, 0 }}, 1},
+ {{{ 0,2, 0,3, 0,1, 1, 1 }}, 1},
+ {{},0},
+};
+
+/*
+ * Get a buffer of edges from cell location
+ */
+static const struct conf *player_walkgrid_conf( struct walkgrid *wg,
+ v2i cell,
+ struct grid_sample *corners[4] )
+{
+ corners[0] = &wg->samples[cell[1] ][cell[0] ];
+ corners[1] = &wg->samples[cell[1]+1][cell[0] ];
+ 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;
- v3f clippos;
- v3_add( pos, clip, clippos );
- draw_cross( clippos, 0xffffff00, 0.05f );
+ 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 );
+ v3_floor( pos, pos );
+ v3_muls( pos, k_gridscale, pos );
+}
+
+/*
+ * Computes the barycentric coordinate of location on a triangle (vertical),
+ * then sets the Y position to the interpolation of the three points
+ */
+static void player_walkgrid_stand_tri( v3f a, v3f b, v3f c, v3f pos )
+{
+ v3f v0,v1,v2;
+ v3_sub( b, a, v0 );
+ v3_sub( c, a, v1 );
+ v3_sub( pos, a, v2 );
+
+ float d = v0[0]*v1[2] - v1[0]*v0[2],
+ v = (v2[0]*v1[2] - v1[0]*v2[2]) / d,
+ w = (v0[0]*v2[2] - v2[0]*v0[2]) / d,
+ u = 1.0f - v - w;
+
+ vg_line( pos, a, 0xffff0000 );
+ vg_line( pos, b, 0xff00ff00 );
+ vg_line( pos, c, 0xff0000ff );
+ pos[1] = u*a[1] + v*b[1] + w*c[1];
+}
+
+/*
+ * Get the minimum time value of pos+dir until a cell edge
+ *
+ * t[0] -> t[3] are the individual time values
+ * t[5] & t[6] are the maximum axis values
+ * t[6] is the minimum value
+ *
+ */
+static void player_walkgrid_min_cell( float t[7], v2f pos, v2f dir )
+{
+ v2f frac = { 1.0f/dir[0], 1.0f/dir[1] };
+
+ t[0] = 999.9f;
+ t[1] = 999.9f;
+ t[2] = 999.9f;
+ t[3] = 999.9f;
+
+ if( fabsf(dir[0]) > 0.0001f )
+ {
+ t[0] = (0.0f-pos[0]) * frac[0];
+ t[1] = (1.0f-pos[0]) * frac[0];
+ }
+ if( fabsf(dir[1]) > 0.0001f )
+ {
+ t[2] = (0.0f-pos[1]) * frac[1];
+ t[3] = (1.0f-pos[1]) * frac[1];
+ }
+
+ t[4] = vg_maxf(t[0],t[1]);
+ t[5] = vg_maxf(t[2],t[3]);
+ t[6] = vg_minf(t[4],t[5]);
+}
+
+static void player_walkgrid_iter(struct walkgrid *wg, int iter)
+{
+
+ /*
+ * For each walkgrid iteration we are stepping through cells and determining
+ * 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;
+ pa[0] = wg->region[0][0] + (float)wg->cell_id[0] *k_gridscale;
+ pa[1] = (wg->region[0][1] + wg->region[1][1]) * 0.5f + k_gridscale;
+ pa[2] = wg->region[0][2] + (float)wg->cell_id[1] *k_gridscale;
+ pb[0] = pa[0];
+ pb[1] = pa[1];
+ pb[2] = pa[2] + k_gridscale;
+ pc[0] = pa[0] + k_gridscale;
+ pc[1] = pa[1];
+ pc[2] = pa[2] + k_gridscale;
+ pd[0] = pa[0] + k_gridscale;
+ pd[1] = pa[1];
+ pd[2] = pa[2];
+#if 0
+ vg_line( pa, pb, 0xff00ffff );
+ vg_line( pb, pc, 0xff00ffff );
+ vg_line( pc, pd, 0xff00ffff );
+ vg_line( pd, pa, 0xff00ffff );
+#endif
+ pl0[0] = pa[0] + wg->pos[0]*k_gridscale;
+ pl0[1] = pa[1];
+ pl0[2] = pa[2] + wg->pos[1]*k_gridscale;
+
+ /*
+ * If there are edges present, we need to create a 'substep' event, where
+ * we find the intersection point, find the fully resolved position,
+ * then the new pos dir is the intersection->resolution
+ *
+ * the resolution is applied in non-discretized space in order to create a
+ * suitable vector for finding outflow, we want it to leave the cell so it
+ * can be used by the quad
+ */
+
+ v2f pos, dir;
+ v2_copy( wg->pos, pos );
+ v2_muls( wg->dir, wg->move, dir );
+
+ struct grid_sample *corners[4];
+ v2f corners2d[4] = {{0.0f,0.0f},{0.0f,1.0f},{1.0f,1.0f},{1.0f,0.0f}};
+ const struct conf *conf = player_walkgrid_conf( wg, wg->cell_id, corners );
+
+ float t[7];
+ player_walkgrid_min_cell( t, pos, dir );
+
+ for( int i=0; i<conf->edge_count; i++ )
+ {
+ const struct confedge *edge = &conf->edges[i];
+
+ v2f e0, e1, n, r, target, res, tangent;
+ e0[0] = corners2d[edge->i0][0] + corners[edge->d0]->clip[edge->a0][0];
+ e0[1] = corners2d[edge->i0][1] + corners[edge->d0]->clip[edge->a0][2];
+ e1[0] = corners2d[edge->i1][0] + corners[edge->d1]->clip[edge->a1][0];
+ e1[1] = corners2d[edge->i1][1] + corners[edge->d1]->clip[edge->a1][2];
+
+ v3f pe0 = { pa[0] + e0[0]*k_gridscale,
+ pa[1],
+ pa[2] + e0[1]*k_gridscale };
+ v3f pe1 = { pa[0] + e1[0]*k_gridscale,
+ pa[1],
+ pa[2] + e1[1]*k_gridscale };
+
+ v2_sub( e1, e0, tangent );
+ n[0] = -tangent[1];
+ n[1] = tangent[0];
+ v2_normalize( n );
+
+ /*
+ * If we find ourselfs already penetrating the edge, move back out a
+ * little
+ */
+ v2_sub( e0, pos, r );
+ float p1 = v2_dot(r,n);
+
+ if( -p1 < 0.0001f )
+ {
+ v2_muladds( pos, n, p1+0.0001f, pos );
+ v2_copy( pos, wg->pos );
+ v3f p_new = { pa[0] + pos[0]*k_gridscale,
+ pa[1],
+ pa[2] + pos[1]*k_gridscale };
+ v3_copy( p_new, pl0 );
+ }
+
+ v2_add( pos, dir, target );
+
+ v2f v1, v2, v3;
+ v2_sub( e0, pos, v1 );
+ v2_sub( target, pos, v2 );
+
+ v2_copy( n, v3 );
+
+ v2_sub( e0, target, r );
+ float p = v2_dot(r,n),
+ t1 = v2_dot(v1,v3)/v2_dot(v2,v3);
+
+ if( t1 < t[6] && t1 > 0.0f && -p < 0.001f )
+ {
+ v2_muladds( target, n, p+0.0001f, res );
+
+ v2f intersect;
+ v2_muladds( pos, dir, t1, intersect );
+ v2_copy( intersect, pos );
+ v2_sub( res, intersect, dir );
+
+ v3f p_res = { pa[0] + res[0]*k_gridscale,
+ pa[1],
+ pa[2] + res[1]*k_gridscale };
+ v3f p_int = { pa[0] + intersect[0]*k_gridscale,
+ pa[1],
+ pa[2] + intersect[1]*k_gridscale };
+
+ vg_line( pl0, p_int, icolours[iter%3] );
+ v3_copy( p_int, pl0 );
+ v2_copy( pos, wg->pos );
+
+ player_walkgrid_min_cell( t, pos, dir );
+ }
+ }
+
+ /*
+ * Compute intersection with grid cell moving outwards
+ */
+ t[6] = vg_minf( t[6], 1.0f );
+
+ pl1[0] = pl0[0] + dir[0]*k_gridscale*t[6];
+ pl1[1] = pl0[1];
+ pl1[2] = pl0[2] + dir[1]*k_gridscale*t[6];
+ vg_line( pl0, pl1, icolours[iter%3] );
+
+ if( t[6] < 1.0f )
+ {
+ /*
+ * To figure out what t value created the clip so we know which edge
+ * to wrap around
+ */
+
+ if( t[4] < t[5] )
+ {
+ wg->pos[1] = pos[1] + dir[1]*t[6];
+
+ if( t[0] > t[1] ) /* left edge */
+ {
+ wg->pos[0] = 0.9999f;
+ wg->cell_id[0] --;
+
+ if( wg->cell_id[0] == 0 )
+ wg->move = -1.0f;
+ }
+ else /* Right edge */
+ {
+ wg->pos[0] = 0.0001f;
+ wg->cell_id[0] ++;
+
+ if( wg->cell_id[0] == WALKGRID_SIZE-2 )
+ wg->move = -1.0f;
+ }
+ }
+ else
+ {
+ wg->pos[0] = pos[0] + dir[0]*t[6];
+
+ if( t[2] > t[3] ) /* bottom edge */
+ {
+ wg->pos[1] = 0.9999f;
+ wg->cell_id[1] --;
+
+ if( wg->cell_id[1] == 0 )
+ wg->move = -1.0f;
+ }
+ else /* top edge */
+ {
+ wg->pos[1] = 0.0001f;
+ wg->cell_id[1] ++;
+
+ if( wg->cell_id[1] == WALKGRID_SIZE-2 )
+ wg->move = -1.0f;
+ }
+ }
+
+ wg->move -= t[6];
+ }
+ else
+ {
+ v2_muladds( wg->pos, dir, wg->move, wg->pos );
+ wg->move = 0.0f;
+ }
+}
+
+static void player_walkgrid_stand_cell(struct walkgrid *wg)
+{
+ /*
+ * NOTE: as opposed to the other function which is done in discretized space
+ * this use a combination of both.
+ */
+
+ v3f world;
+ world[0] = wg->region[0][0]+((float)wg->cell_id[0]+wg->pos[0])*k_gridscale;
+ world[2] = wg->region[0][2]+((float)wg->cell_id[1]+wg->pos[1])*k_gridscale;
+
+ struct grid_sample *corners[4];
+ const struct conf *conf = player_walkgrid_conf( wg, wg->cell_id, corners );
+
+ if( conf != k_walkgrid_configs )
+ {
+ if( conf->edge_count == 0 )
+ {
+ v3f v0;
+
+ /* Split the basic quad along the shortest diagonal */
+ if( fabsf(corners[2]->pos[1] - corners[0]->pos[1]) <
+ fabsf(corners[3]->pos[1] - corners[1]->pos[1]) )
+ {
+ vg_line( corners[2]->pos, corners[0]->pos, 0xffaaaaaa );
+
+ if( wg->pos[0] > wg->pos[1] )
+ player_walkgrid_stand_tri( corners[0]->pos,
+ corners[3]->pos,
+ corners[2]->pos, world );
+ else
+ player_walkgrid_stand_tri( corners[0]->pos,
+ corners[2]->pos,
+ corners[1]->pos, world );
+ }
+ else
+ {
+ vg_line( corners[3]->pos, corners[1]->pos, 0xffaaaaaa );
+
+ if( wg->pos[0] < 1.0f-wg->pos[1] )
+ player_walkgrid_stand_tri( corners[0]->pos,
+ corners[3]->pos,
+ corners[1]->pos, world );
+ else
+ player_walkgrid_stand_tri( corners[3]->pos,
+ corners[2]->pos,
+ corners[1]->pos, world );
+ }
+ }
+ else
+ {
+ for( int i=0; i<conf->edge_count; i++ )
+ {
+ const struct confedge *edge = &conf->edges[i];
+
+ v3f p0, p1;
+ v3_muladds( corners[edge->i0]->pos,
+ corners[edge->d0]->clip[edge->a0], k_gridscale, p0 );
+ v3_muladds( corners[edge->i1]->pos,
+ corners[edge->d1]->clip[edge->a1], k_gridscale, p1 );
+
+ /*
+ * Find penetration distance between player position and the edge
+ */
+
+ v2f normal = { -(p1[2]-p0[2]), p1[0]-p0[0] },
+ rel = { world[0]-p0[0], world[2]-p0[2] };
+
+ if( edge->o0 == -1 )
+ {
+ /* No subregions (default case), just use triangle created by
+ * i0, e0, e1 */
+ player_walkgrid_stand_tri( corners[edge->i0]->pos,
+ p0,
+ p1, world );
+ }
+ else
+ {
+ /*
+ * Test if we are in the first region, which is
+ * edge.i0, edge.e0, edge.o0,
+ */
+ v3f v0, ref;
+ v3_sub( p0, corners[edge->o0]->pos, ref );
+ v3_sub( world, corners[edge->o0]->pos, v0 );
+
+ vg_line( corners[edge->o0]->pos, p0, 0xffffff00 );
+ vg_line( corners[edge->o0]->pos, world, 0xff000000 );
+
+ if( ref[0]*v0[2] - ref[2]*v0[0] < 0.0f )
+ {
+ player_walkgrid_stand_tri( corners[edge->i0]->pos,
+ p0,
+ corners[edge->o0]->pos, world );
+ }
+ else
+ {
+ if( edge->o1 == -1 )
+ {
+ /*
+ * No other edges mean we just need to use the opposite
+ *
+ * e0, e1, o0 (in our case, also i1)
+ */
+ player_walkgrid_stand_tri( p0,
+ p1,
+ corners[edge->o0]->pos, world );
+ }
+ else
+ {
+ /*
+ * Note: this v0 calculation can be ommited with the
+ * current tileset.
+ *
+ * the last two triangles we have are:
+ * e0, e1, o1
+ * and
+ * e1, i1, o1
+ */
+ v3_sub( p1, corners[edge->o1]->pos, ref );
+ v3_sub( world, corners[edge->o1]->pos, v0 );
+ vg_line( corners[edge->o1]->pos, p1, 0xff00ffff );
+
+ if( ref[0]*v0[2] - ref[2]*v0[0] < 0.0f )
+ {
+ player_walkgrid_stand_tri( p0,
+ p1,
+ corners[edge->o1]->pos,
+ world );
+ }
+ else
+ {
+ player_walkgrid_stand_tri( p1,
+ corners[edge->i1]->pos,
+ corners[edge->o1]->pos,
+ world );
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ v3_copy( world, player.co );
}
static void player_walkgrid_getsurface(void)
{
- float const k_gridscale = 0.5f;
float const k_stepheight = 0.5f;
- float const k_walkspeed = 6.0f;
float const k_miny = 0.6f;
float const k_height = 1.78f;
- int const k_gridamt = 8;
- float const k_region_size = (float)k_gridamt/2.0f * k_gridscale;
+ float const k_region_size = (float)WALKGRID_SIZE/2.0f * k_gridscale;
- v3f cell;
- v3_muls( player.co, 1.0f/k_gridscale, cell );
- v3_floor( cell, cell );
- v3_muls( cell, k_gridscale, cell );
+ struct walkgrid wg;
- u32 geo[128];
+ v3f cell;
+ v3_copy( player.co, cell );
+ player_walkgrid_floor( cell );
- boxf region;
- v3_muladds( cell, (v3f){-1.0f,-1.0f,-1.0f}, k_region_size, region[0] );
- v3_muladds( cell, (v3f){ 1.0f, 1.0f, 1.0f}, k_region_size, region[1] );
+ 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, region, geo, 128 );
+ int tri_count = bvh_select_triangles( &world.geo, wg.region, wg.geo, 256 );
v3f tri[3];
for( int i=0; i<tri_count; i++ )
{
for( int j=0; j<3; j++ )
- v3_copy( world.geo.verts[ world.geo.indices[geo[i]+j] ].co, tri[j] );
+ v3_copy( world.geo.verts[ world.geo.indices[wg.geo[i]+j]].co, tri[j] );
-#if 0
vg_line( tri[0], tri[1], 0xffa2ff30 );
vg_line( tri[1], tri[2], 0xffa2ff30 );
vg_line( tri[2], tri[0], 0xffa2ff30 );
-#endif
}
- struct grid_sample
- {
- int valid;
- v3f clip[2];
- v3f pos;
- }
- samples[ k_gridamt ][ k_gridamt ];
-
- /* Get surface samples */
- for( int y=0; y<k_gridamt; y++ )
+ /* 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<k_gridamt; x++ )
+ for( int x=0; x<WALKGRID_SIZE; x++ )
{
- struct grid_sample *s = &samples[y][x];
- v3_muladds( region[0], (v3f){ x, 0, y }, k_gridscale, s->pos );
+ 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( geo, tri_count, s->pos )? 1: 0;
+ s->valid = player_walkgrid_samplepole( wg.geo,tri_count,s->pos )? 1: 0;
}
}
*/
for( int i=0; i<2; i++ )
{
- for( int x=0; x<k_gridamt; x++ )
+ for( int x=0; x<WALKGRID_SIZE; x++ )
{
- for( int z=0; z<k_gridamt-1; z++ )
+ 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 = &samples[z][x];
- sb = &samples[z+1][x];
+ sa = &wg.samples[z][x];
+ sb = &wg.samples[z+1][x];
}
else
{
- sa = &samples[x][z];
- sb = &samples[x][z+1];
+ sa = &wg.samples[x][z];
+ sb = &wg.samples[x][z+1];
}
if( sa->valid != sb->valid )
{
- clipdir[i*2] = (float)(sa->valid - sb->valid)*k_gridscale;
- player_walkgrid_clip( geo, tri_count,
+ 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] );
}
}
/* Draw connections */
- for( int x=0; x<k_gridamt-1; x++ )
+ struct grid_sample *corners[4];
+ for( int x=0; x<WALKGRID_SIZE-1; x++ )
{
- for( int z=0; z<k_gridamt-1; z++ )
+ for( int z=0; z<WALKGRID_SIZE-1; z++ )
{
- static const struct conf
- {
- struct confedge
- {
- /* i: sample index
- * d: data index
- * a: axis index
- */
- int i0, i1,
- d0, d1,
- a0, a1;
- }
- edges[2];
- int edge_count;
- }
- k_configs[16] = {
- {{},0},
- {{{ 3, 3, 3, 0, 1,0 }}, 1},
- {{{ 2, 2, 1, 3, 0,1 }}, 1},
- {{{ 2, 3, 1, 0, 0,0 }}, 1},
-
- {{{ 1, 1, 0, 1, 1,0 }}, 1},
- {{{ 3, 3, 3, 0, 1,0 },
- { 1, 1, 0, 1, 1,0 }}, 2},
- {{{ 1, 2, 0, 3, 1,1 }}, 1},
- {{{ 1, 3, 0, 0, 1,0 }}, 1},
-
- {{{ 0, 0, 0, 0, 0,1 }}, 1},
- {{{ 3, 0, 3, 0, 1,1 }}, 1},
- {{{ 2, 2, 1, 3, 0,1 },
- { 0, 0, 0, 0, 0,1 }}, 2},
- {{{ 2, 0, 1, 0, 0,1 }}, 1},
-
- {{{ 0, 1, 0, 1, 0,0 }}, 1},
- {{{ 3, 1, 3, 1, 1,0 }}, 1},
- {{{ 0, 2, 0, 3, 0,1 }}, 1},
- {{},0},
- };
-
- struct grid_sample *corners[4] =
- {
- &samples[z][x],
- &samples[z+1][x],
- &samples[z+1][x+1],
- &samples[z][x+1]
- };
-
- u32 config = (corners[0]->valid<<3) | (corners[1]->valid<<2) |
- (corners[2]->valid<<1) | corners[3]->valid;
-
- const struct conf *conf = &k_configs[ config ];
+ const struct conf *conf =
+ player_walkgrid_conf( &wg, (v2i){x,z}, corners );
for( int i=0; i<conf->edge_count; i++ )
{
const struct confedge *edge = &conf->edges[i];
v3f p0, p1;
- v3_add( corners[edge->i0]->pos,
- corners[edge->d0]->clip[edge->a0], p0 );
- v3_add( corners[edge->i1]->pos,
- corners[edge->d1]->clip[edge->a1], p1 );
+ v3_muladds( corners[edge->i0]->pos,
+ 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 );
}
}
}
-}
-
-static void player_walkgrid(void)
-{
- player_walkgrid_getsurface();
-
- float const k_gridscale = 0.5f;
- float const k_stepheight = 0.5f;
- float const k_walkspeed = 6.0f;
- float const k_miny = 0.6f;
- float const k_height = 1.78f;
- int const k_gridamt = 8;
-#if 0
- v3f cell;
- v3_muls( player.co, 1.0f/k_gridscale, cell );
- v3_floor( cell, cell );
- v3_muls( cell, k_gridscale, cell );
+ /*
+ * Commit player movement into the grid
+ */
- struct grid_sample
+ 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() )
{
- ray_hit hit;
- int valid;
+ 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 );
}
- samples[ k_gridamt ][ k_gridamt ];
-
- v3f grid_origin;
- v3_muladds( cell, (v3f){ -1.0f,0.0f,-1.0f },
- (float)(k_gridamt/2) * k_gridscale, grid_origin );
+ if( v3_length2(delta) <= 0.00001f )
+ return;
+
/*
- * Get sample 'poles'
+ * Create our move in grid space
*/
- for( int y=0; y<k_gridamt; y++ )
- {
- for( int x=0; x<k_gridamt; x++ )
- {
- v3f sample_coord;
- v3_muladds( grid_origin, (v3f){ x, 0, y }, k_gridscale, sample_coord );
- sample_coord[1] += k_height;
+ wg.dir[0] = delta[0] * (1.0f/k_gridscale);
+ wg.dir[1] = delta[2] * (1.0f/k_gridscale);
+ wg.move = 1.0f;
- struct grid_sample *sample = &samples[y][x];
- sample->valid = 0;
- sample->hit.dist = k_stepheight+k_height;
-
- if( ray_world( sample_coord, (v3f){0.0f,-1.0f,0.0f}, &sample->hit ))
- {
- if( sample->hit.normal[1] >= k_miny &&
- ray_hit_is_ramp( &sample->hit ))
- {
- sample->valid = 1;
- draw_cross( sample->hit.pos, 0xff00ff00, 0.1f );
- }
- else
- draw_cross( sample->hit.pos, 0xff0000ff, 0.1f );
- }
- }
- }
-
- /*
- * Clip grid intersections with triangle edges
- */
- for( int dir=0; dir<2; dir++ )
+ v2f region_pos =
{
- for( int x=0; x<k_gridamt; x++ )
- {
- for( int y=0; y<k_gridamt-1; y++ )
- {
- struct grid_sample *sa, *sb;
-
- if( dir == 0 )
- {
- sa = &samples[y][x];
- sb = &samples[y+1][x];
- }
- else
- {
- sa = &samples[x][y];
- sb = &samples[x][y+1];
- }
-
- if( (sa->valid != sb->valid) && (sa->valid||sb->valid) )
- {
- int line = dir==0? 0:2,
- axis = dir==0? 2:0;
-
- v3f tri[3];
- ray_world_get_tri( sa->valid? &sa->hit: &sb->hit, tri );
-
- v3f other = {0,0,0};
- other[axis] = sa->valid? k_gridscale: -k_gridscale;
- v3_add( sa->valid? sa->hit.pos: sb->hit.pos, other, other );
- vg_line( sa->valid? sa->hit.pos: sb->hit.pos,
- other, 0xffffffff );
-
- v3f sample;
- if( dir == 0 )
- v3_muladds( grid_origin, (v3f){ x, 0, y }, k_gridscale, sample);
- else
- v3_muladds( grid_origin, (v3f){ y, 0, x }, k_gridscale, sample);
-
- /* Clip triangles until we find an edge inside the cell */
- float offset = sample[line],
- basis = sample[axis];
-
- for( int i=0; i<3; i++ )
- {
- int ia = i,
- ib = (i+1)%3;
- float pa = tri[ia][line],
- pb = tri[ib][line];
-
- vg_line( tri[ia],tri[ib],0xffaaaaaa );
-
- if( (pa-offset)*(pb-offset) > 0.0f )
- continue;
-
- float d = pb-pa,
- qa = (offset-pa)/d,
- h = qa*tri[ib][axis] + (1.0f-qa)*tri[ia][axis],
- q = (h-basis)/k_gridscale;
+ (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 );
- if( q >= 0.0f && q <= 1.0f )
- {
- float height = qa*tri[ia][1] + (1.0f-qa)*tri[ib][1];
- v3f intersection;
- if( dir == 0 )
- v3_copy( (v3f){ offset, height, h }, intersection );
- else
- v3_copy( (v3f){ h, height, offset }, intersection );
- draw_cross( intersection, 0xffff0000, 0.06f );
- break;
- }
- }
- }
- }
- }
- }
-#endif
- v3f fwd = { -sinf(-player.angles[0]), 0.0f, -cosf(-player.angles[0]) },
- side = { -fwd[2], 0.0f, fwd[0] };
+ player_walkgrid_stand_cell( &wg );
+}
- /* Temp */
- if( glfwGetKey( vg_window, GLFW_KEY_W ) )
- v3_muladds( player.co, fwd, ktimestep*k_walkspeed, player.co );
- if( glfwGetKey( vg_window, GLFW_KEY_S ) )
- v3_muladds( player.co, fwd, -ktimestep*k_walkspeed, player.co );
-
- if( glfwGetKey( vg_window, GLFW_KEY_A ) )
- v3_muladds( player.co, side, -ktimestep*k_walkspeed, player.co );
- if( glfwGetKey( vg_window, GLFW_KEY_D ) )
- v3_muladds( player.co, side, ktimestep*k_walkspeed, player.co );
+static void player_walkgrid(void)
+{
+ player_walkgrid_getsurface();
m4x3_mulv( player.to_world, (v3f){0.0f,1.8f,0.0f}, player.camera_pos );
player_mouseview();
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff