#include "audio.h"
#include "common.h"
-#include "character.h"
+#include "world.h"
+//#include "character.h"
+#include "player_model.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_accel = 10.0f,
k_push_cycle_rate = 8.0f,
k_steer_ground = 2.5f,
k_steer_air = 3.6f,
k_steer_air_lerp = 0.3f,
- k_downforce = 5.0f;
+ k_pump_force = 000.0f,
+ k_downforce = 5.0f,
+ k_jump_charge_speed = (1.0f/1.0f),
+ k_jump_force = 5.0f;
static int freecam = 0;
static int walk_grid_iterations = 1;
+static float fc_speed = 10.0f;
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;
v2f board_xy;
float grab;
float pitch;
-
+ float pushing, push_time;
+ float jump;
+ int jump_charge;
+
v3f land_target;
v3f land_target_log[22];
u32 land_target_colours[22];
int land_log_count;
m3x3f vr,vr_pstep;
-
- m4x3f to_world, to_local;
struct character mdl;
v3f camera_pos, smooth_localcam;
v2f angles;
m4x3f camera, camera_inverse;
+
+ /* animation */
+ double jump_time;
+ float fslide,
+ fdirz, fdirx,
+ fstand,
+ ffly,
+ fpush,
+ fairdir,
+ fsetup;
}
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
v2_sub( vg_mouse, mouse_last, delta );
v2_copy( vg_mouse, mouse_last );
- v2_muladds( view_vel, delta, 0.005f, view_vel );
+ v2_muladds( view_vel, delta, 0.001f, 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_muls( view_vel, 0.93f, 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 );
}
{
player_mouseview();
- float movespeed = 25.0f;
+ float movespeed = fc_speed;
v3f lookdir = { 0.0f, 0.0f, -1.0f },
sidedir = { 1.0f, 0.0f, 0.0f };
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;
if( vg_get_button_down( "push" ) )
start_push = vg_time;
+ if( vg_get_button( "jump" ) )
+ {
+ player.jump += ktimestep * k_jump_charge_speed;
+ player.jump_charge = 1;
+ }
+
if( !vg_get_button("break") && vg_get_button( "push" ) )
{
- float cycle_time = (vg_time-start_push)*k_push_cycle_rate,
+ player.pushing = 1.0f;
+ player.push_time = vg_time-start_push;
+
+ float cycle_time = player.push_time*k_push_cycle_rate,
amt = k_push_accel * (sinf(cycle_time)*0.5f+0.5f)*ktimestep,
current = v3_length( vel ),
new_vel = vg_minf( current + amt, k_max_push_speed );
+
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] );
+ rb_update_bounds( rbf );
+ rb_update_bounds( rbb );
- vg_line(tri[0],tri[1],0xff00ff00 );
- vg_line(tri[1],tri[2],0xff00ff00 );
- vg_line(tri[2],tri[0],0xff00ff00 );
+ rb_debug( rbf, 0xff00ffff );
+ rb_debug( rbb, 0xffffff00 );
- v3f co, norm;
- float p;
+ rb_ct manifold[24];
+ int len = 0;
- 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;
- }
+ len += rb_sphere_vs_scene( rbf, &world.rb_geo, manifold+len );
+ len += rb_sphere_vs_scene( rbb, &world.rb_geo, manifold+len );
- v3f p1;
- v3_muladds( poles[j], norm, p, p1 );
- vg_line( poles[j], p1, 0xffffffff );
-
- 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;
-
- 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 );
+ player.pushing = 0.0f;
+
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();
+
+ if( !player.jump_charge && player.jump > 0.2f )
+ {
+ v3_muladds( player.rb.v, player.rb.up, k_jump_force*player.jump,
+ player.rb.v );
+
+ player.jump_time = vg_time;
+ }
}
else
{
player_physics_control_air();
}
+
+ if( !player.jump_charge )
+ {
+ player.jump -= k_jump_charge_speed * ktimestep;
+ }
+ player.jump_charge = 0;
+ player.jump = vg_clampf( player.jump, 0.0f, 1.0f );
}
static void player_do_motion(void)
/* 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 );
-
+ offset[1] = 0.0f;
/*
* Animation blending
* ===========================================
*/
- static float fslide = 0.0f;
- static float fdirz = 0.0f;
- static float fdirx = 0.0f;
- static float fstand = 0.0f;
- static float ffly = 0.0f;
-
- float speed = v3_length( player.v );
+ /* scalar blending information */
+ 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);
- fdirz = vg_lerpf(fdirz, player.reverse > 0.0f? 1.0f: 0.0f, 0.04f );
- fdirx = vg_lerpf(fdirx, player.slip < 0.0f? 1.0f: 0.0f, 0.01f );
- ffly = vg_lerpf(ffly, player.in_air? 1.0f: 0.0f, 0.04f );
-
- character_pose_reset( &player.mdl );
-
- /* TODO */
- float fstand1 = 1.0f-(1.0f-fstand)*0.3f;
-
- float amt_air = ffly*ffly,
- amt_ground = 1.0f-amt_air,
- amt_std = (1.0f-fslide) * amt_ground,
- amt_stand = amt_std * fstand1,
- amt_aero = amt_std * (1.0f-fstand1),
- amt_slide = amt_ground * fslide;
-
- 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) );
-
- character_final_pose( &player.mdl, (v3f){0.0f,0.0f,0.0f},
- &pose_fly, amt_air );
+ /* sliding */
+ {
+ float desired = vg_clampf( lslip, 0.0f, 1.0f );
+ player.fslide = vg_lerpf( player.fslide, desired, 0.04f );
+ }
+ /* movement information */
+ {
+ float dirz = player.reverse > 0.0f? 0.0f: 1.0f,
+ dirx = player.slip < 0.0f? 0.0f: 1.0f,
+ fly = player.in_air? 1.0f: 0.0f;
- /*
- * Additive effects
- * ==========================
- */
- struct ik_basic *arm_l = &player.mdl.ik_arm_l,
- *arm_r = &player.mdl.ik_arm_r;
-
- v3f localv;
- m3x3_mulv( player.to_local, player.v, localv );
+ player.fdirz = vg_lerpf( player.fdirz, dirz, 0.04f );
+ player.fdirx = vg_lerpf( player.fdirx, dirx, 0.01f );
+ player.ffly = vg_lerpf( player.ffly, fly, 0.04f );
+ }
+
+ struct skeleton *sk = &player.mdl.sk;
- /* New board transformation */
- v4f board_rotation; v3f board_location;
+ mdl_keyframe apose[32], bpose[32];
+ mdl_keyframe ground_pose[32];
+ {
+ /* when the player is moving fast he will crouch down a little bit */
+ float stand = 1.0f - vg_clampf( speed * 0.03f, 0.0f, 1.0f );
+ player.fstand = vg_lerpf( player.fstand, stand, 0.1f );
- v4f rz, rx;
- q_axis_angle( rz, (v3f){ 0.0f, 0.0f, 1.0f }, player.board_xy[0] );
- q_axis_angle( rx, (v3f){ 1.0f, 0.0f, 0.0f }, player.board_xy[1] );
- q_mul( rx, rz, board_rotation );
-
- v3f *mboard = player.mdl.matrices[k_chpart_board];// player.mboard;
- q_m3x3( board_rotation, mboard );
- m3x3_mulv( mboard, (v3f){ 0.0f, -0.5f, 0.0f }, board_location );
- v3_add( (v3f){0.0f,0.5f,0.0f}, board_location, board_location );
- v3_copy( board_location, mboard[3] );
+ /* stand/crouch */
+ float dir_frame = player.fdirz * (15.0f/30.0f),
+ stand_blend = offset[1]*-2.0f;
+
+ skeleton_sample_anim( sk, player.mdl.anim_stand, dir_frame, apose );
+ skeleton_sample_anim( sk, player.mdl.anim_highg, dir_frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
+ /* sliding */
+ float slide_frame = player.fdirx * (15.0f/30.0f);
+ skeleton_sample_anim( sk, player.mdl.anim_slide, slide_frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, player.fslide, apose );
- float wheel_r = offset[0]*-0.4f;
- v4f qwheel;
- q_axis_angle( qwheel, (v3f){0.0f,1.0f,0.0f}, wheel_r );
-
- q_m3x3( qwheel, player.mdl.matrices[k_chpart_wb] );
-
- m3x3_transpose( player.mdl.matrices[k_chpart_wb],
- player.mdl.matrices[k_chpart_wf] );
- v3_copy( player.mdl.offsets[k_chpart_wb],
- player.mdl.matrices[k_chpart_wb][3] );
- v3_copy( player.mdl.offsets[k_chpart_wf],
- player.mdl.matrices[k_chpart_wf][3] );
-
- m4x3_mul( mboard, player.mdl.matrices[k_chpart_wb],
- player.mdl.matrices[k_chpart_wb] );
- m4x3_mul( mboard, player.mdl.matrices[k_chpart_wf],
- player.mdl.matrices[k_chpart_wf] );
+ /* pushing */
+ player.fpush = vg_lerpf( player.fpush, player.pushing, 0.1f );
- m4x3_mulv( mboard, player.mdl.ik_leg_l.end, player.mdl.ik_leg_l.end );
- m4x3_mulv( mboard, player.mdl.ik_leg_r.end, player.mdl.ik_leg_r.end );
+ float pt = player.push_time;
+ if( player.reverse > 0.0f )
+ skeleton_sample_anim( sk, player.mdl.anim_push, pt, bpose );
+ else
+ skeleton_sample_anim( sk, player.mdl.anim_push_reverse, pt, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, player.fpush, apose );
- v3_copy( player.mdl.ik_arm_l.end, player.handl_target );
- v3_copy( player.mdl.ik_arm_r.end, player.handr_target );
+ /* trick setup */
+ float setup_frame = player.jump * (12.0f/30.0f),
+ setup_blend = vg_minf( player.jump*5.0f, 1.0f );
+
+ float jump_frame = (vg_time - player.jump_time) + (12.0f/30.0f);
+ if( jump_frame >= (12.0f/30.0f) && jump_frame <= (40.0f/30.0f) )
+ setup_frame = jump_frame;
- if( 1||player.in_air )
+ skeleton_sample_anim_clamped( sk, player.mdl.anim_ollie,
+ setup_frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
+ }
+
+ mdl_keyframe air_pose[32];
{
- float tuck = player.board_xy[1],
- tuck_amt = fabsf( tuck ) * (1.0f-fabsf(player.board_xy[0]));
+ float target = -vg_get_axis("horizontal");
+ player.fairdir = vg_lerpf( player.fairdir, target, 0.04f );
- float crouch = player.grab*0.3f;
- v3_muladds( player.mdl.ik_body.base, (v3f){0.0f,-1.0f,0.0f},
- crouch, player.mdl.ik_body.base );
- v3_muladds( player.mdl.ik_body.end, (v3f){0.0f,-1.0f,0.0f},
- crouch*1.2f, player.mdl.ik_body.end );
-
- if( tuck < 0.0f )
- {
- //foot_l *= 1.0f-tuck_amt*1.5f;
-
- if( player.grab > 0.1f )
- {
- m4x3_mulv( mboard, (v3f){0.1f,0.14f,0.6f},
- player.handl_target );
- }
- }
- else
- {
- //foot_r *= 1.0f-tuck_amt*1.4f;
-
- if( player.grab > 0.1f )
- {
- m4x3_mulv( mboard, (v3f){0.1f,0.14f,-0.6f},
- player.handr_target );
- }
- }
+ float air_frame = (player.fairdir*0.5f+0.5f) * (15.0f/30.0f);
+
+ skeleton_sample_anim( sk, player.mdl.anim_air, air_frame, air_pose );
}
- v3_lerp( player.handl, player.handl_target, 1.0f, player.handl );
- v3_lerp( player.handr, player.handr_target, 1.0f, player.handr );
-
- v3_copy( player.handl, player.mdl.ik_arm_l.end );
- v3_copy( player.handr, player.mdl.ik_arm_r.end );
-
- /* Head rotation */
-
- static float rhead = 0.0f;
- static const float klook_max = 0.8f;
- rhead = vg_lerpf( rhead,
- vg_clampf( atan2f(localv[2],-localv[0]),-klook_max,klook_max), 0.04f );
- player.mdl.rhead = rhead;
+ skeleton_lerp_pose( sk, ground_pose, air_pose, player.ffly, apose );
+
+ /* additive effects */
+ apose[player.mdl.id_hip-1].co[0] += offset[0];
+ apose[player.mdl.id_hip-1].co[2] += offset[2];
+ apose[player.mdl.id_ik_hand_l-1].co[0] += offset[0];
+ apose[player.mdl.id_ik_hand_l-1].co[2] += offset[2];
+ apose[player.mdl.id_ik_hand_r-1].co[0] += offset[0];
+ apose[player.mdl.id_ik_hand_r-1].co[2] += offset[2];
+ apose[player.mdl.id_ik_elbow_l-1].co[0] += offset[0];
+ apose[player.mdl.id_ik_elbow_l-1].co[2] += offset[2];
+ apose[player.mdl.id_ik_elbow_r-1].co[0] += offset[0];
+ apose[player.mdl.id_ik_elbow_r-1].co[2] += offset[2];
+
+ skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_defer_ik );
+ skeleton_apply_ik_pass( &player.mdl.sk );
+ skeleton_apply_pose( &player.mdl.sk, apose, k_anim_apply_deffered_only );
+
+ v3_copy( player.mdl.sk.final_mtx[player.mdl.id_head-1][3],
+ player.mdl.cam_pos );
+ skeleton_apply_inverses( &player.mdl.sk );
+ skeleton_apply_transform( &player.mdl.sk, player.rb.to_world );
+
+ skeleton_debug( &player.mdl.sk );
}
static void player_camera_update(void)
static void player_animate_death_cam(void)
{
+#if 0
v3f delta;
v3f head_pos;
v3_copy( player.mdl.ragdoll[k_chpart_head].co, head_pos );
player.angles[0] = atan2f( delta[0], -delta[2] );
player.angles[1] = -asinf( delta[1] );
+#endif
}
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 );
- v3_add( offs, player.camera_pos, player.camera_pos );
+ static v3f lerp_cam = {0.0f,0.0f,0.0f};
+ v3f offs = { -0.4f, 0.15f, 0.0f };
+
+ v3_lerp( lerp_cam, player.mdl.cam_pos, 0.8f, lerp_cam );
+ v3_add( lerp_cam, offs, offs );
+ m4x3_mulv( player.rb.to_world, offs, 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 );
+#if 0
+ 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
+
+ shader_viewchar_use();
+ vg_tex2d_bind( &tex_characters, 0 );
+ shader_viewchar_uTexMain( 0 );
+ shader_viewchar_uCamera( player.camera[3] );
+ shader_viewchar_uPv( vg_pv );
+ shader_link_standard_ub( _shader_viewchar.id, 2 );
+ glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
+ player.mdl.sk.bone_count,
+ 0,
+ (float *)player.mdl.sk.final_mtx );
+
+ mesh_bind( &player.mdl.mesh );
+ mesh_draw( &player.mdl.mesh );
}
#endif /* PLAYER_H */