#include "audio.h"
#include "common.h"
+#include "world.h"
#include "character.h"
#include "bvh.h"
static float
k_walkspeed = 2.0f,
- k_board_radius = 0.25f,
- k_board_length = 0.65f,
+ k_board_radius = 0.3f,
+ k_board_length = 0.45f,
k_board_allowance = 0.04f,
- k_friction_lat = 8.68f,
- k_friction_resistance = 0.02f,
+ k_friction_lat = 8.8f,
+ k_friction_resistance = 0.01f,
k_max_push_speed = 16.0f,
k_push_accel = 5.0f,
k_push_cycle_rate = 8.0f,
k_steer_ground = 2.5f,
k_steer_air = 3.6f,
k_steer_air_lerp = 0.3f,
+ k_pump_force = 000.0f,
k_downforce = 5.0f;
static int freecam = 0;
static struct gplayer
{
/* Physics */
- v3f co, v, w, a, v_last, m, bob, vl;
+ rigidbody rb, collide_front, collide_back, rb_gate_frame;
- /* Utility */
- v3f up, right, forward;
+ v3f a, v_last, m, bob, vl;
- v4f rot;
+ /* Utility */
float vswitch, slip, slip_last,
reverse;
- int rf, rb;
- v3f ctf, ctb;
-
float iY; /* Yaw inertia */
int in_air, is_dead, on_board;
u32 land_target_colours[22];
int land_log_count;
m3x3f vr,vr_pstep;
-
- m4x3f to_world, to_local;
struct character mdl;
}
player =
{
- .on_board = 1
+ .on_board = 1,
+
+ .collide_front = { .type = k_rb_shape_sphere, .inf.sphere.radius = 0.3f },
+ .collide_back = { .type = k_rb_shape_sphere, .inf.sphere.radius = 0.3f }
};
/*
* Player API
*/
-static void player_transform_update(void)
-{
- q_normalize( player.rot );
- q_m3x3( player.rot, player.to_world );
- v3_copy( player.co, player.to_world[3] );
-
- m4x3_invert_affine( player.to_world, player.to_local );
-
- m3x3_mulv( player.to_world, (v3f){1.0f,0.0f, 0.0f}, player.right );
- m3x3_mulv( player.to_world, (v3f){0.0f,1.0f, 0.0f}, player.up );
- m3x3_mulv( player.to_world, (v3f){0.0f,0.0f,-1.0f}, player.forward );
-}
/*
* Free camera movement
player.in_air = 1;
float pstep = ktimestep*10.0f;
-
- float best_velocity_mod = 0.0f,
- best_velocity_delta = -9999.9f;
-
- float k_bias = 0.97f;
+ float best_velocity_delta = -9999.9f;
+ float k_bias = 0.96f;
v3f axis;
- v3_cross( player.up, player.v, axis );
+ v3_cross( player.rb.up, player.rb.v, axis );
v3_normalize( axis );
player.land_log_count = 0;
float vmod = ((float)m / 15.0f)*0.09f;
v3f pco, pco1, pv;
- v3_copy( player.co, pco );
- v3_muls( player.v, k_bias, pv );
+ v3_copy( player.rb.co, pco );
+ v3_muls( player.rb.v, k_bias, pv );
/*
* Try different 'rotations' of the velocity to find the best possible
if( (land_delta < 0.0f) && (land_delta > best_velocity_delta) )
{
best_velocity_delta = land_delta;
- best_velocity_mod = vmod;
v3_copy( contact.pos, player.land_target );
*/
v3f vel;
- m3x3_mulv( player.to_local, player.v, vel );
+ m3x3_mulv( player.rb.to_local, player.rb.v, vel );
float slip = 0.0f;
if( fabsf(vel[2]) > 0.01f )
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] ) * -8.78f *substep );
+ vel[0] = stable_force( vel[0],
+ vg_signf( vel[0] ) * -k_friction_lat*substep );
}
static double start_push = 0.0;
new_vel -= vg_minf(current, k_max_push_speed);
vel[2] -= new_vel * player.reverse;
}
+
+ /* Pumping */
+ static float previous = 0.0f;
+ float delta = previous - player.grab,
+ pump = delta * k_pump_force*ktimestep;
+ previous = player.grab;
+
+ v3f p1;
+ v3_muladds( player.rb.co, player.rb.up, pump, p1 );
+ vg_line( player.rb.co, p1, 0xff0000ff );
+
+ vel[1] += pump;
+
- m3x3_mulv( player.to_world, vel, player.v );
+ m3x3_mulv( player.rb.to_world, vel, player.rb.v );
float steer = vg_get_axis( "horizontal" );
player.iY -= vg_signf(steer)*powf(steer,2.0f) * k_steer_ground * ktimestep;
static void player_physics_control_air(void)
{
- m3x3_mulv( player.vr, player.v, player.v );
+ m3x3_mulv( player.vr, player.rb.v, player.rb.v );
draw_cross( player.land_target, 0xff0000ff, 0.25f );
ray_hit hit;
float pstep = ktimestep*10.0f;
v3f pco, pco1, pv;
- v3_copy( player.co, pco );
- v3_copy( player.v, pv );
+ v3_copy( player.rb.co, pco );
+ v3_copy( player.rb.v, pv );
float time_to_impact = 0.0f;
float limiter = 1.0f;
float orig_dist = contact.dist;
if( ray_world( pco1, vdir, &contact ))
{
- v3f localup;
- m3x3_mulv( player.to_world, (v3f){0.0f,1.0f,0.0f}, localup );
-
- float angle = v3_dot( localup, contact.normal );
+ float angle = v3_dot( player.rb.up, contact.normal );
v3f axis;
- v3_cross( localup, contact.normal, axis );
+ v3_cross( player.rb.up, contact.normal, axis );
time_to_impact += (contact.dist/orig_dist)*pstep;
limiter = vg_minf( 5.0f, time_to_impact )/5.0f;
{
v4f correction;
q_axis_angle( correction, axis, acosf(angle)*0.05f*(1.0f-limiter) );
- q_mul( correction, player.rot, player.rot );
+ q_mul( correction, player.rb.q, player.rb.q );
}
draw_cross( contact.pos, 0xffff0000, 0.25f );
siX = vg_lerpf( siX, iX, k_steer_air_lerp );
v4f rotate;
- v3f vside;
-
- m3x3_mulv( player.to_world, (v3f){1.0f,0.0f,0.0f}, vside );
-
- q_axis_angle( rotate, vside, siX );
- q_mul( rotate, player.rot, player.rot );
+ q_axis_angle( rotate, player.rb.right, siX );
+ q_mul( rotate, player.rb.q, player.rb.q );
}
v2f target = {0.0f,0.0f};
v2_lerp( player.board_xy, target, ktimestep*3.0f, player.board_xy );
}
-static void player_physics(void)
+static void player_init(void)
{
- m4x3f mboard;
- v3_copy( player.to_world[0], mboard[0] );
- v3_copy( player.to_world[2], mboard[1] );
- v3_copy( player.to_world[1], mboard[2] );
- m4x3_mulv( player.to_world, (v3f){ 0.0f, 0.3f, 0.0f }, mboard[3] );
-
- debug_capsule( mboard, k_board_length*2.0f, k_board_radius, 0xff0000ff );
+ rb_init( &player.collide_front );
+ rb_init( &player.collide_back );
+}
- boxf region = {{ -k_board_radius, -k_board_length, -k_board_radius },
- { k_board_radius, k_board_length, k_board_radius }};
- m4x3_transform_aabb( mboard, region );
+static void player_physics(void)
+{
+ /*
+ * Update collision fronts
+ */
- u32 geo[256];
- v3f tri[3];
- int len = bh_select( &world.geo.bhtris, region, geo, 256 );
+ rigidbody *rbf = &player.collide_front,
+ *rbb = &player.collide_back;
- v3f poles[2];
- m4x3_mulv(mboard, (v3f){0.0f,-k_board_length+k_board_radius,0.0f}, poles[0]);
- m4x3_mulv(mboard, (v3f){0.0f, k_board_length-k_board_radius,0.0f}, poles[1]);
+ m3x3_copy( player.rb.to_world, player.collide_front.to_world );
+ m3x3_copy( player.rb.to_world, player.collide_back.to_world );
- struct contact manifold[12];
- int manifold_count = 0;
+ player.air_blend = vg_lerpf( player.air_blend, player.in_air, 0.1f );
+ float h = player.air_blend*0.2f;
- v3f surface_avg = {0.0f, 0.0f, 0.0f};
+ m4x3_mulv( player.rb.to_world, (v3f){0.0f,h,-k_board_length}, rbf->co );
+ v3_copy( rbf->co, rbf->to_world[3] );
+ m4x3_mulv( player.rb.to_world, (v3f){0.0f,h, k_board_length}, rbb->co );
+ v3_copy( rbb->co, rbb->to_world[3] );
- for( int i=0; i<len; i++ )
- {
- u32 *ptri = &world.geo.indices[ geo[i]*3 ];
+ m4x3_invert_affine( rbf->to_world, rbf->to_local );
+ m4x3_invert_affine( rbb->to_world, rbb->to_local );
- for( int j=0; j<3; j++ )
- v3_copy( world.geo.verts[ptri[j]].co, tri[j] );
-
- vg_line(tri[0],tri[1],0xff00ff00 );
- vg_line(tri[1],tri[2],0xff00ff00 );
- vg_line(tri[2],tri[0],0xff00ff00 );
+ rb_update_bounds( rbf );
+ rb_update_bounds( rbb );
- v3f co, norm;
- float p;
-
- for( int j=0; j<2; j++ )
- {
- if( sphere_vs_triangle( poles[j], k_board_radius, tri,co,norm,&p) )
- {
- if(manifold_count >= vg_list_size(manifold))
- {
- vg_error("Manifold overflow!\n");
- break;
- }
+ rb_debug( rbf, 0xff00ffff );
+ rb_debug( rbb, 0xffffff00 );
- v3f p1;
- v3_muladds( poles[j], norm, p, p1 );
- vg_line( poles[j], p1, 0xffffffff );
+ rb_ct manifold[24];
+ int len = 0;
- struct contact *ct = &manifold[manifold_count ++];
- v3_sub( co, player.co, ct->delta );
- v3_copy( co, ct->co );
- v3_copy( norm, ct->n );
- ct->bias = -0.2f*k_rb_rate*vg_minf(0.0f,-p+k_board_allowance);
- ct->norm_impulse = 0.0f;
+ len += rb_sphere_vs_scene( rbf, &world.rb_geo, manifold+len );
+ len += rb_sphere_vs_scene( rbb, &world.rb_geo, manifold+len );
- v3_add( norm, surface_avg, surface_avg );
- }
- }
- }
+ rb_presolve_contacts( manifold, len );
+ v3f surface_avg = {0.0f, 0.0f, 0.0f};
- if( !manifold_count )
+ if( !len )
{
player_start_air();
}
else
{
+ for( int i=0; i<len; i++ )
+ {
+ v3_add( manifold[i].n, surface_avg, surface_avg );
+
+#if 0
+ if( manifold[i].element_id <= world.sm_geo_std_oob.vertex_count )
+ {
+ player.is_dead = 1;
+ character_ragdoll_copypose( &player.mdl, player.rb.v );
+ return;
+ }
+#endif
+ }
+
v3_normalize( surface_avg );
- if( v3_dot( player.v, surface_avg ) > 0.5f )
+ if( v3_dot( player.rb.v, surface_avg ) > 0.5f )
{
player_start_air();
}
player.in_air = 0;
}
- for( int j=0; j<10; j++ )
+ for( int j=0; j<5; j++ )
{
- for( int i=0; i<manifold_count; i++ )
+ for( int i=0; i<len; i++ )
{
struct contact *ct = &manifold[i];
- v3f dv;
- v3_cross( player.w, ct->delta, dv );
- v3_add( player.v, dv, dv );
+ v3f dv, delta;
+ v3_sub( ct->co, player.rb.co, delta );
+ v3_cross( player.rb.w, delta, dv );
+ v3_add( player.rb.v, dv, dv );
float vn = -v3_dot( dv, ct->n );
vn += ct->bias;
vn = ct->norm_impulse - temp;
v3f impulse;
-
v3_muls( ct->n, vn, impulse );
- v3_add( impulse, player.v, player.v );
- v3_cross( ct->delta, impulse, impulse );
+ if( fabsf(v3_dot( impulse, player.rb.forward )) > 10.0f ||
+ fabsf(v3_dot( impulse, player.rb.up )) > 50.0f )
+ {
+ player.is_dead = 1;
+ character_ragdoll_copypose( &player.mdl, player.rb.v );
+ return;
+ }
+
+ v3_add( impulse, player.rb.v, player.rb.v );
+ v3_cross( delta, impulse, impulse );
/*
* W Impulses are limited to the Y and X axises, we don't really want
* components.
*/
- float wy = v3_dot( player.up, impulse ),
- wx = v3_dot( player.right, impulse );
+ float wy = v3_dot( player.rb.up, impulse ),
+ wx = v3_dot( player.rb.right, impulse )*1.5f;
- v3_muladds( player.w, player.up, wy, player.w );
- v3_muladds( player.w, player.right, wx, player.w );
+ v3_muladds( player.rb.w, player.rb.up, wy, player.rb.w );
+ v3_muladds( player.rb.w, player.rb.right, wx, player.rb.w );
}
}
+ float grabt = vg_get_axis( "grabr" )*0.5f+0.5f;
+ player.grab = vg_lerpf( player.grab, grabt, 0.14f );
+
if( !player.in_air )
{
v3f axis;
- float angle = v3_dot( player.up, surface_avg );
- v3_cross( player.up, surface_avg, axis );
+ float angle = v3_dot( player.rb.up, surface_avg );
+ v3_cross( player.rb.up, surface_avg, axis );
- float cz = v3_dot( player.forward, axis );
- v3_muls( player.forward, cz, axis );
+ //float cz = v3_dot( player.rb.forward, axis );
+ //v3_muls( player.rb.forward, cz, axis );
if( angle < 0.999f )
{
v4f correction;
q_axis_angle( correction, axis, acosf(angle)*0.3f );
- q_mul( correction, player.rot, player.rot );
+ q_mul( correction, player.rb.q, player.rb.q );
}
- v3_muladds( player.v, player.up, -k_downforce*ktimestep, player.v );
+ v3_muladds( player.rb.v, player.rb.up,
+ -k_downforce*ktimestep, player.rb.v );
player_physics_control();
}
else
/* Integrate velocity */
v3f prevco;
- v3_copy( player.co, prevco );
+ v3_copy( player.rb.co, prevco );
- apply_gravity( player.v, ktimestep );
- v3_muladds( player.co, player.v, ktimestep, player.co );
+ apply_gravity( player.rb.v, ktimestep );
+ v3_muladds( player.rb.co, player.rb.v, ktimestep, player.rb.co );
/* Real angular velocity integration */
- v3_lerp( player.w, (v3f){0.0f,0.0f,0.0f}, 0.125f, player.w );
- if( v3_length2( player.w ) > 0.0f )
+ v3_lerp( player.rb.w, (v3f){0.0f,0.0f,0.0f}, 0.125f, player.rb.w );
+ if( v3_length2( player.rb.w ) > 0.0f )
{
v4f rotation;
v3f axis;
- v3_copy( player.w, axis );
+ v3_copy( player.rb.w, axis );
float mag = v3_length( axis );
v3_divs( axis, mag, axis );
q_axis_angle( rotation, axis, mag*k_rb_delta );
- q_mul( rotation, player.rot, player.rot );
+ q_mul( rotation, player.rb.q, player.rb.q );
}
/* Faux angular velocity */
float lerpq = player.in_air? 0.04f: 0.3f;
siY = vg_lerpf( siY, player.iY, lerpq );
- q_axis_angle( rotate, player.up, siY );
- q_mul( rotate, player.rot, player.rot );
+ q_axis_angle( rotate, player.rb.up, siY );
+ q_mul( rotate, player.rb.q, player.rb.q );
player.iY = 0.0f;
/*
* Gate intersection, by tracing a line over the gate planes
*/
- for( int i=0; i<world.gate_count; i++ )
+ for( int i=0; i<world.routes.gate_count; i++ )
{
- teleport_gate *gate = &world.gates[i];
+ struct route_gate *rg = &world.routes.gates[i];
+ teleport_gate *gate = &rg->gate;
- if( gate_intersect( gate, player.co, prevco ) )
+ if( gate_intersect( gate, player.rb.co, prevco ) )
{
- m4x3_mulv( gate->transport, player.co, player.co );
- m3x3_mulv( gate->transport, player.v, player.v );
+ m4x3_mulv( gate->transport, player.rb.co, player.rb.co );
+ m3x3_mulv( gate->transport, player.rb.v, player.rb.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 );
v4f transport_rotation;
m3x3_q( gate->transport, transport_rotation );
- q_mul( transport_rotation, player.rot, player.rot );
-
+ q_mul( transport_rotation, player.rb.q, player.rb.q );
+
+ world_routes_activate_gate( i );
+ player.rb_gate_frame = player.rb;
break;
}
}
-
- player_transform_update();
+
+ rb_update_transform( &player.rb );
}
/*
static int player_walkgrid_tri_walkable( u32 tri[3] )
{
- return tri[0] < world.sm_surface.vertex_count;
+ return tri[0] > world.sm_geo_std_oob.vertex_count;
}
/*
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;
+#if 0
pb[0] = pa[0];
pb[1] = pa[1];
pb[2] = pa[2] + k_gridscale;
pd[0] = pa[0] + k_gridscale;
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 );
v3f world;
world[0] = wg->region[0][0]+((float)wg->cell_id[0]+wg->pos[0])*k_gridscale;
- world[1] = player.co[1];
+ world[1] = player.rb.co[1];
world[2] = wg->region[0][2]+((float)wg->cell_id[1]+wg->pos[1])*k_gridscale;
struct grid_sample *corners[4];
}
}
- v3_copy( world, player.co );
+ v3_copy( world, player.rb.co );
}
static void player_walkgrid_getsurface(void)
static struct walkgrid wg;
v3f cell;
- v3_copy( player.co, cell );
+ v3_copy( player.rb.co, cell );
player_walkgrid_floor( cell );
v3_muladds( cell, (v3f){-1.0f,-1.0f,-1.0f}, k_region_size, wg.region[0] );
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)
+ (player.rb.co[0] - wg.region[0][0]) * (1.0f/k_gridscale),
+ (player.rb.co[2] - wg.region[0][2]) * (1.0f/k_gridscale)
};
v2f region_cell_pos;
v2_floor( region_pos, region_cell_pos );
{
player_walkgrid_getsurface();
- m4x3_mulv( player.to_world, (v3f){0.0f,1.8f,0.0f}, player.camera_pos );
+ m4x3_mulv( player.rb.to_world, (v3f){0.0f,1.8f,0.0f}, player.camera_pos );
player_mouseview();
- player_transform_update();
+ rb_update_transform( &player.rb );
}
/*
static void player_animate(void)
{
/* Camera position */
- v3_sub( player.v, player.v_last, player.a );
- v3_copy( player.v, player.v_last );
+ v3_sub( player.rb.v, player.v_last, player.a );
+ v3_copy( player.rb.v, player.v_last );
v3_add( player.m, player.a, player.m );
v3_lerp( player.m, (v3f){0.0f,0.0f,0.0f}, 0.1f, player.m );
/* Head */
float lslip = fabsf(player.slip);
-
- float grabt = vg_get_axis( "grabr" )*0.5f+0.5f;
- player.grab = vg_lerpf( player.grab, grabt, 0.04f );
float kheight = 2.0f,
kleg = 0.6f;
v3f offset;
- m3x3_mulv( player.to_local, player.bob, offset );
+ v3_zero( offset );
+ m3x3_mulv( player.rb.to_local, player.bob, offset );
static float speed_wobble = 0.0f, speed_wobble_2 = 0.0f;
- float kickspeed = vg_clampf(v3_length(player.v)*(1.0f/40.0f), 0.0f, 1.0f);
+ float kickspeed = vg_clampf(v3_length(player.rb.v)*(1.0f/40.0f), 0.0f, 1.0f);
float kicks = (vg_randf()-0.5f)*2.0f*kickspeed;
float sign = vg_signf( kicks );
speed_wobble = vg_lerpf( speed_wobble, kicks*kicks*sign, 0.1f );
offset[0] = vg_clampf( offset[0], -0.8f, 0.8f );
offset[1] = vg_clampf( offset[1], -0.5f, 0.0f );
+ /*
+ * Player rotation
+ */
+#if 0
+ float angle = v3_dot( player.rb.up, (v3f){0.0f,1.0f,0.0f} );
+ v3f axis;
+ v3_cross( player.rb.up, (v3f){0.0f,1.0f,0.0f}, axis );
+
+ v4f correction;
+ if( angle < 0.99f && 0 )
+ {
+ m3x3_mulv( player.rb.to_local, axis, axis );
+ q_axis_angle( correction, axis, acosf(angle) );
+ }
+ else
+ {
+ q_identity( correction );
+ }
/*
* Animation blending
* ===========================================
*/
+#endif
static float fslide = 0.0f;
static float fdirz = 0.0f;
static float fstand = 0.0f;
static float ffly = 0.0f;
- float speed = v3_length( player.v );
+ float speed = v3_length( player.rb.v );
fstand = vg_lerpf(fstand, 1.0f-vg_clampf(speed*0.03f,0.0f,1.0f),0.1f);
fslide = vg_lerpf(fslide, vg_clampf(lslip,0.0f,1.0f), 0.04f);
character_pose_reset( &player.mdl );
/* TODO */
- float fstand1 = 1.0f-(1.0f-fstand)*0.3f;
+ float fstand1 = 1.0f-(1.0f-fstand)*0.0f;
float amt_air = ffly*ffly,
amt_ground = 1.0f-amt_air,
character_final_pose( &player.mdl, offset,
&pose_slide1, amt_slide*(1.0f-fdirx) );
- character_final_pose( &player.mdl, (v3f){0.0f,0.0f,0.0f},
+ character_final_pose( &player.mdl, (v4f){0.0f,0.0f,0.0f,1.0f},
&pose_fly, amt_air );
-
/*
* Additive effects
*arm_r = &player.mdl.ik_arm_r;
v3f localv;
- m3x3_mulv( player.to_local, player.v, localv );
+ m3x3_mulv( player.rb.to_local, player.rb.v, localv );
/* New board transformation */
v4f board_rotation; v3f board_location;
static void player_animate_camera(void)
{
v3f offs = { -0.29f, 0.08f, 0.0f };
- m3x3_mulv( player.to_world, offs, offs );
- m4x3_mulv( player.to_world, player.mdl.ik_body.end, player.camera_pos );
+ m3x3_mulv( player.rb.to_world, offs, offs );
+ m4x3_mulv( player.rb.to_world, player.mdl.ik_body.end, player.camera_pos );
v3_add( offs, player.camera_pos, player.camera_pos );
/* Look angles */
- v3_lerp( player.vl, player.v, 0.05f, player.vl );
+ v3_lerp( player.vl, player.rb.v, 0.05f, player.vl );
float yaw = atan2f( player.vl[0], -player.vl[2] ),
pitch = atan2f( -player.vl[1],
/* Camera shake */
static v2f shake_damp = {0.0f,0.0f};
v2f shake = { vg_randf()-0.5f, vg_randf()-0.5f };
- v2_muls( shake, v3_length(player.v)*0.3f *(1.0f+fabsf(player.slip)), shake);
+ v2_muls( shake, v3_length(player.rb.v)*0.3f
+ * (1.0f+fabsf(player.slip)), shake);
+
v2_lerp( shake_damp, shake, 0.01f, shake_damp );
shake_damp[0] *= 0.2f;
*/
static void player_audio(void)
{
- float speed = vg_minf(v3_length( player.v )*0.1f,1.0f),
- attn = v3_dist( player.co, player.camera[3] )+1.0f;
+ float speed = vg_minf(v3_length( player.rb.v )*0.1f,1.0f),
+ attn = v3_dist( player.rb.co, player.camera[3] )+1.0f;
attn = (1.0f/(attn*attn)) * speed;
static float air = 0.0f;
v3f ears = { 1.0f,0.0f,0.0f };
v3f delta;
- v3_sub( player.co, player.camera[3], delta );
+ v3_sub( player.rb.co, player.camera[3], delta );
v3_normalize( delta );
m3x3_mulv( player.camera, ears, ears );
{
float min_dist = INFINITY;
- vg_info( "%f %f %f\n", player.co[0], player.co[1], player.co[2] );
for( int i=0; i<world.spawn_count; i++ )
{
r = &world.spawns[i];
- float d = v3_dist2( r->co, player.co );
+ float d = v3_dist2( r->co, player.rb.co );
vg_info( "Dist %s : %f\n", r->name, d );
if( d < min_dist )
rp = &world.spawns[0];
}
- v4_copy( rp->q, player.rot );
- v3_copy( rp->co, player.co );
+ v4_copy( rp->q, player.rb.q );
+ v3_copy( rp->co, player.rb.co );
player.vswitch = 1.0f;
player.slip_last = 0.0f;
player.mdl.shoes[0] = 1;
player.mdl.shoes[1] = 1;
+
+ rb_update_transform( &player.rb );
+ m3x3_mulv( player.rb.to_world, (v3f){ 0.0f, 0.0f, -1.2f }, player.rb.v );
- player_transform_update();
- m3x3_mulv( player.to_world, (v3f){ 0.0f, 0.0f, -1.2f }, player.v );
+ player.rb_gate_frame = player.rb;
return 1;
}
player.land_target_colours[i], 0.25f);
if( vg_get_axis("grabl")>0.0f)
- reset_player(0,NULL);
+ {
+ player.rb = player.rb_gate_frame;
+ player.is_dead = 0;
+ player.in_air = 1;
+ m3x3_identity( player.vr );
+
+ player.mdl.shoes[0] = 1;
+ player.mdl.shoes[1] = 1;
+
+ world_routes_notify_reset();
+ }
if( vg_get_button_down( "switchmode" ) )
{
static void draw_player(void)
{
/* Draw */
- m4x3_copy( player.to_world, player.mdl.mroot );
+ m4x3_copy( player.rb.to_world, player.mdl.mroot );
if( player.is_dead )
character_mimic_ragdoll( &player.mdl );
if( player.is_dead )
opacity = 0.0f;
- character_draw( &player.mdl, opacity );
+ character_draw( &player.mdl, opacity, player.camera );
}
#endif /* PLAYER_H */
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff