#include "common.h"
#include "character.h"
+#include "bvh.h"
static int freecam = 0;
static float k_walkspeed = 2.0f;
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;
if( vg_get_button_down( "primary" ) )
v2_copy( vg_mouse, mouse_last );
+
else if( vg_get_button( "primary" ) )
{
v2f delta;
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)
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 );
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
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++ )
{
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 );
}
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;
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;
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 );
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 );
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;
-
- 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 );
}
static int player_walkgrid_tri_walkable( u32 tri[3] )
}
samples[WALKGRID_SIZE][WALKGRID_SIZE];
-#if 0
- u32 geo[256];
-#endif
-
boxf region;
float move; /* Current amount of movement we have left to apply */
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;
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] );
{
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->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;
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;
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] );
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];
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] );
}
}
-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
* 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;
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 );
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 );
}
/*
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++ )
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++ )
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
* ===========================================
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) );
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
* ==========================
for( int i=0; i<len; i++ )
{
- if( (points[i][2]-points[p][2])*(points[q][0]-points[i][0]) -
- (points[i][0]-points[p][0])*(points[q][2]-points[i][2])
- > 0.0001f )
+ 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;
}
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] );
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],
d = 1.0f/(yb-ya),
qa;
- if( (ya-0.2f) * (yb-0.2f) < 0.0f )
- {
- v3_muls( verts[ia], (yb-0.2f)*d, p0 );
- v3_muladds( p0, verts[ib], -(ya-0.2f)*d, p0 );
-
- v3_copy( p0, hull[hull_len] );
- hull[hull_len ++][1] = 0.2f;
-
- m4x3_mulv( player.to_world, p0, p0 );
- vg_line_pt3( p0, 0.1f, 0xffffff00 );
- }
-
- if( (ya-kheight) * (yb-kheight) < 0.0f )
+ float planes[] = { 0.2f, kheight };
+
+ for( int k=0; k<vg_list_size(planes); k++ )
{
- v3_muls( verts[ia], (yb-kheight)*d, p0 );
- v3_muladds( p0, verts[ib], -(ya-kheight)*d, p0 );
+ float clip = planes[k];
- v3_copy( p0, hull[hull_len] );
- hull[hull_len ++][1] = 0.2f;
+ 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;
+ }
+ }
- m4x3_mulv( player.to_world, p0, p0 );
- vg_line_pt3( p0, 0.1f, 0xff00ffff );
- }
- }
- for( int i=0; i<8; i++ )
- {
- int ia = indices[i][0];
- float ya = verts[ia][1];
+ if( add_point )
+ v3_copy( p0, hull[hull_len ++] );
- if( ya > 0.2f && ya < kheight )
- {
- v3_copy( verts[ia], hull[hull_len] );
- hull[hull_len ++][1] = 0.2f;
+ m4x3_mulv( player.to_world, p0, p0 );
+ vg_line_pt3( p0, 0.1f, 0xffffff00 );
+ }
}
}
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 );
vg_line( p0, p2, 0xff00ffa0 );
}
- int collide = 1;
- float min_dist = 99999.9f;
- v2f normal;
- for( int i=0; i<len; i++ )
+ v2f endpoints[] = {{ 0.0f, -1.0f },{ 0.0f, 1.0f }};
+
+ for( int j=0; j<vg_list_size(endpoints); j++ )
{
- 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( (v2f){ 0.0f, -1.0f }, p0, rel );
- float d = -v2_dot( n, rel ) + 0.5f;
+ v2f point;
+ v2_copy( endpoints[j], point );
- if( d < 0.0f )
+ int collide = 1;
+ float min_dist = 99999.9f;
+ v2f normal = {0.0f,0.0f};
+ for( int i=0; i<len; i++ )
{
- collide = 0;
- break;
- }
+ 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 < min_dist )
- {
- min_dist = d;
- v2_copy( n, normal );
- }
- }
+ if( d < 0.0f )
+ {
+ collide = 0;
+ break;
+ }
- if( collide )
- {
- v3f p0, p1;
- p0[0] = 0.0f;
- p0[1] = 0.2f;
- p0[2] = -1.0f;
+ if( d < min_dist )
+ {
+ min_dist = d;
+ v2_copy( n, normal );
+ }
+ }
- 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 );
+ 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 );
+ vg_line( p0, p1, 0xffffffff );
+
+ v3f vel;
+ m3x3_mulv( player.to_local, player.v, vel );
+ vel[1] = vel[2];
- v2f impulse;
- v2_muls( normal, min_dist, impulse );
- float rotation = v2_cross( (v2f){0.0f,-1.0f}, impulse )*0.08f;
-
- 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;
+ }
- 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 );
+ 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] };
+ 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 );
-
- 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 );
+ 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();
{
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 )
{
- for( int i=0; i<world.rb_count; i++ )
- player_do_collision( &world.temp_rbs[i] );
+ 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();
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff