+ if( way < 0.0f ) allow_front = 0;
+ else allow_back = 0;
+ }
+ }
+
+ if( state->activity == k_skate_activity_grind_boardslide ){
+ res_slide = skate_boardslide_renew( &inf_slide );
+ }
+ else if( state->activity == k_skate_activity_grind_back50 ){
+ res_back50 = skate_grind_truck_renew( 1.0f, &inf_back50 );
+
+ if( allow_front )
+ res_front50 = skate_grind_truck_entry( -1.0f, &inf_front50 );
+ }
+ else if( state->activity == k_skate_activity_grind_front50 ){
+ res_front50 = skate_grind_truck_renew( -1.0f, &inf_front50 );
+
+ if( allow_back )
+ res_back50 = skate_grind_truck_entry( 1.0f, &inf_back50 );
+ }
+ else if( state->activity == k_skate_activity_grind_5050 ){
+ if( allow_front )
+ res_front50 = skate_grind_truck_renew( -1.0f, &inf_front50 );
+ if( allow_back )
+ res_back50 = skate_grind_truck_renew( 1.0f, &inf_back50 );
+ }
+ else{
+ res_slide = skate_boardslide_entry( &inf_slide );
+
+ if( allow_back )
+ res_back50 = skate_grind_truck_entry( 1.0f, &inf_back50 );
+
+ if( allow_front )
+ res_front50 = skate_grind_truck_entry( -1.0f, &inf_front50 );
+
+ if( res_back50 != res_front50 ){
+ int wants_to_do_that = fabsf(steer[1]) >= 0.25f;
+
+ res_back50 &= wants_to_do_that;
+ res_front50 &= wants_to_do_that;
+ }
+ }
+
+ const enum skate_activity table[] =
+ { /* slide | back | front */
+ k_skate_activity_undefined, /* 0 0 0 */
+ k_skate_activity_grind_front50, /* 0 0 1 */
+ k_skate_activity_grind_back50, /* 0 1 0 */
+ k_skate_activity_grind_5050, /* 0 1 1 */
+
+ /* slide has priority always */
+ k_skate_activity_grind_boardslide, /* 1 0 0 */
+ k_skate_activity_grind_boardslide, /* 1 0 1 */
+ k_skate_activity_grind_boardslide, /* 1 1 0 */
+ k_skate_activity_grind_boardslide, /* 1 1 1 */
+ }
+ , new_activity = table[ res_slide << 2 | res_back50 << 1 | res_front50 ];
+
+ if( new_activity == k_skate_activity_undefined ){
+ if( state->activity >= k_skate_activity_grind_any ){
+ state->grind_cooldown = 15;
+ state->surface_cooldown = 10;
+ }
+ }
+ else if( new_activity == k_skate_activity_grind_boardslide ){
+ skate_boardslide_apply( &inf_slide );
+ }
+ else if( new_activity == k_skate_activity_grind_back50 ){
+ if( state->activity != k_skate_activity_grind_back50 )
+ skate_store_grind_vec( &inf_back50 );
+
+ skate_grind_truck_apply( 1.0f, &inf_back50, 1.0f );
+ }
+ else if( new_activity == k_skate_activity_grind_front50 ){
+ if( state->activity != k_skate_activity_grind_front50 )
+ skate_store_grind_vec( &inf_front50 );
+
+ skate_grind_truck_apply( -1.0f, &inf_front50, 1.0f );
+ }
+ else if( new_activity == k_skate_activity_grind_5050 )
+ skate_5050_apply( &inf_front50, &inf_back50 );
+
+ return new_activity;
+}
+
+static void player__skate_update(void){
+ struct player_skate_state *state = &player_skate.state;
+ world_instance *world = world_current_instance();
+
+ if( world->water.enabled ){
+ if( localplayer.rb.co[1]+0.25f < world->water.height ){
+#if 0
+ player__networked_sfx( k_player_subsystem_walk, 32,
+ k_player_walk_soundeffect_splash,
+ localplayer.rb.co, 1.0f );
+#endif
+ player__skate_kill_audio();
+ player__dead_transition();
+ return;
+ }
+ }
+
+ v3_copy( localplayer.rb.co, state->prev_pos );
+ state->activity_prev = state->activity;
+ v3f normal_total;
+ v3_zero( normal_total );
+
+ struct board_collider
+ {
+ v3f pos;
+ float radius;
+
+ u32 colour;
+
+ enum board_collider_state
+ {
+ k_collider_state_default,
+ k_collider_state_disabled,
+ k_collider_state_colliding
+ }
+ state;
+ }
+ wheels[] =
+ {
+ {
+ { 0.0f, 0.0f, -k_board_length },
+ .radius = k_board_radius,
+ .colour = VG__RED
+ },
+ {
+ { 0.0f, 0.0f, k_board_length },
+ .radius = k_board_radius,
+ .colour = VG__GREEN
+ }
+ };
+
+ float slap = 0.0f;
+
+ if( state->activity <= k_skate_activity_air_to_grind ){
+ float min_dist = 0.6f;
+ for( int i=0; i<2; i++ ){
+ v3f wpos, closest;
+ m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, wpos );
+
+ if( bh_closest_point( world->geo_bh, wpos, closest, min_dist ) != -1 ){
+ min_dist = vg_minf( min_dist, v3_dist( closest, wpos ) );
+ }
+ }
+ min_dist -= 0.2f;
+ float vy = v3_dot( localplayer.basis[1], localplayer.rb.v );
+ vy = vg_maxf( 0.0f, vy );
+
+ slap = vg_clampf( (min_dist/0.5f) + vy, 0.0f, 1.0f )*0.3f;
+ }
+ state->slap = vg_lerpf( state->slap, slap, 10.0f*k_rb_delta );
+
+ wheels[0].pos[1] = state->slap;
+ wheels[1].pos[1] = state->slap;
+
+
+ const int k_wheel_count = 2;
+
+ player_skate.substep = k_rb_delta;
+ player_skate.substep_delta = player_skate.substep;
+ player_skate.limit_count = 0;
+
+ int substep_count = 0;
+
+ v3_zero( player_skate.surface_picture );
+
+ int prev_contacts[2];
+
+ for( int i=0; i<k_wheel_count; i++ ){
+ wheels[i].state = k_collider_state_default;
+ prev_contacts[i] = player_skate.wheel_contacts[i];
+ }
+
+ /* check if we can enter or continue grind */
+ enum skate_activity grindable_activity = skate_availible_grind();
+ if( grindable_activity != k_skate_activity_undefined ){
+ state->activity = grindable_activity;
+ goto grinding;
+ }
+
+ int contact_count = 0;
+ for( int i=0; i<2; i++ ){
+ v3f normal, axel;
+ v3_copy( localplayer.rb.to_world[0], axel );
+
+ if( skate_compute_surface_alignment( wheels[i].pos,
+ wheels[i].colour, normal, axel ) )
+ {
+ rb_effect_spring_target_vector( &localplayer.rb,
+ localplayer.rb.to_world[0],
+ axel,
+ k_surface_spring, k_surface_dampener,
+ player_skate.substep_delta );
+
+ v3_add( normal, player_skate.surface_picture,
+ player_skate.surface_picture );
+ contact_count ++;
+ player_skate.wheel_contacts[i] = 1;
+ }
+ else{
+ player_skate.wheel_contacts[i] = 0;
+ }
+
+ m3x3_mulv( localplayer.rb.to_local, axel, player_skate.truckv0[i] );
+ }
+
+ if( state->surface_cooldown ){
+ state->surface_cooldown --;
+ contact_count = 0;
+ }
+
+ if( (prev_contacts[0]+prev_contacts[1] == 1) && (contact_count == 2) ){
+ for( int i=0; i<2; i++ ){
+ if( !prev_contacts[i] ){
+ v3f co;
+ m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, co );
+ player__networked_sfx( k_player_subsystem_skate, 32,
+ k_player_skate_soundeffect_tap,
+ localplayer.rb.co, 0.75f );
+ }
+ }
+ }
+
+ if( contact_count ){
+ state->activity = k_skate_activity_ground;
+ state->gravity_bias = k_gravity;
+ v3_normalize( player_skate.surface_picture );
+
+ skate_apply_friction_model();
+ skate_weight_distribute();
+ }
+ else{
+ if( state->activity > k_skate_activity_air_to_grind )
+ state->activity = k_skate_activity_air;
+
+ v3_zero( player_skate.weight_distribution );
+ skate_apply_air_model();
+ }
+
+grinding:;
+
+ if( state->activity == k_skate_activity_grind_back50 )
+ wheels[1].state = k_collider_state_disabled;
+ if( state->activity == k_skate_activity_grind_front50 )
+ wheels[0].state = k_collider_state_disabled;
+ if( state->activity == k_skate_activity_grind_5050 ){
+ wheels[0].state = k_collider_state_disabled;
+ wheels[1].state = k_collider_state_disabled;
+ }
+
+ /* all activities */
+ skate_apply_steering_model();
+ skate_adjust_up_direction();
+ skate_apply_cog_model();
+ skate_apply_jump_model();
+ skate_apply_grab_model();
+ skate_apply_trick_model();
+ skate_apply_pump_model();
+
+begin_collision:;
+
+ /*
+ * Phase 0: Continous collision detection
+ * --------------------------------------------------------------------------
+ */
+
+ v3f head_wp0, head_wp1, start_co;
+ m4x3_mulv( localplayer.rb.to_world, state->head_position, head_wp0 );
+ v3_copy( localplayer.rb.co, start_co );
+
+ /* calculate transform one step into future */
+ v3f future_co;
+ v4f future_q;
+ v3_muladds( localplayer.rb.co, localplayer.rb.v, player_skate.substep,
+ future_co );
+
+ if( v3_length2( localplayer.rb.w ) > 0.0f ){
+ v4f rotation;
+ v3f axis;
+ v3_copy( localplayer.rb.w, axis );
+
+ float mag = v3_length( axis );
+ v3_divs( axis, mag, axis );
+ q_axis_angle( rotation, axis, mag*player_skate.substep );
+ q_mul( rotation, localplayer.rb.q, future_q );
+ q_normalize( future_q );
+ }
+ else
+ v4_copy( localplayer.rb.q, future_q );
+
+ v3f future_cg, current_cg, cg_offset;
+ q_mulv( localplayer.rb.q, player_skate.weight_distribution, current_cg );
+ q_mulv( future_q, player_skate.weight_distribution, future_cg );
+ v3_sub( future_cg, current_cg, cg_offset );
+
+ /* calculate the minimum time we can move */
+ float max_time = player_skate.substep;
+
+ for( int i=0; i<k_wheel_count; i++ ){
+ if( wheels[i].state == k_collider_state_disabled )
+ continue;
+
+ v3f current, future, r_cg;
+
+ q_mulv( future_q, wheels[i].pos, future );
+ v3_add( future, future_co, future );
+ v3_add( cg_offset, future, future );
+
+ q_mulv( localplayer.rb.q, wheels[i].pos, current );
+ v3_add( current, localplayer.rb.co, current );
+
+ float t;
+ v3f n;
+
+ float cast_radius = wheels[i].radius - k_penetration_slop * 2.0f;
+ if( spherecast_world( world, current, future, cast_radius, &t, n,
+ k_material_flag_walking ) != -1)
+ max_time = vg_minf( max_time, t * player_skate.substep );
+ }
+
+ /* clamp to a fraction of delta, to prevent locking */
+ float rate_lock = substep_count;
+ rate_lock *= k_rb_delta * 0.1f;
+ rate_lock *= rate_lock;
+
+ max_time = vg_maxf( max_time, rate_lock );
+ player_skate.substep_delta = max_time;
+
+ /* integrate */
+ v3_muladds( localplayer.rb.co, localplayer.rb.v,
+ player_skate.substep_delta, localplayer.rb.co );
+ if( v3_length2( localplayer.rb.w ) > 0.0f ){
+ v4f rotation;
+ v3f axis;
+ v3_copy( localplayer.rb.w, axis );
+
+ float mag = v3_length( axis );
+ v3_divs( axis, mag, axis );
+ q_axis_angle( rotation, axis, mag*player_skate.substep_delta );
+ q_mul( rotation, localplayer.rb.q, localplayer.rb.q );
+ q_normalize( localplayer.rb.q );
+
+ q_mulv( localplayer.rb.q, player_skate.weight_distribution, future_cg );
+ v3_sub( current_cg, future_cg, cg_offset );
+ v3_add( localplayer.rb.co, cg_offset, localplayer.rb.co );
+ }
+
+ rb_update_transform( &localplayer.rb );
+ v3_muladds( localplayer.rb.v, localplayer.basis[1],
+ -state->gravity_bias * player_skate.substep_delta,
+ localplayer.rb.v );
+
+ player_skate.substep -= player_skate.substep_delta;
+
+ rb_ct manifold[128];
+ int manifold_len = 0;
+ /*
+ * Phase -1: head detection
+ * --------------------------------------------------------------------------
+ */
+ m4x3_mulv( localplayer.rb.to_world, state->head_position, head_wp1 );
+
+ float t;
+ v3f n;
+ if( (v3_dist2( head_wp0, head_wp1 ) > 0.001f) &&
+ (spherecast_world( world, head_wp0, head_wp1, 0.2f, &t, n,
+ k_material_flag_walking ) != -1) )
+ {
+ v3_lerp( start_co, localplayer.rb.co, t, localplayer.rb.co );
+ rb_update_transform( &localplayer.rb );
+
+ player__skate_kill_audio();
+ player__dead_transition();
+ return;
+ }
+
+ /*
+ * Phase 1: Regular collision detection
+ * --------------------------------------------------------------------------
+ */
+
+ for( int i=0; i<k_wheel_count; i++ ){
+ if( wheels[i].state == k_collider_state_disabled )
+ continue;
+
+ m4x3f mtx;
+ m3x3_identity( mtx );
+ m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, mtx[3] );
+
+ rb_sphere collider = { .radius = wheels[i].radius };
+
+ rb_ct *man = &manifold[ manifold_len ];
+
+ int l = skate_collide_smooth( mtx, &collider, man );
+ if( l )
+ wheels[i].state = k_collider_state_colliding;
+
+ manifold_len += l;
+ }
+
+ float grind_radius = k_board_radius * 0.75f;
+ rb_capsule capsule = { .height = (k_board_length+0.2f)*2.0f,
+ .radius=grind_radius };
+ m4x3f mtx;
+ v3_muls( localplayer.rb.to_world[0], 1.0f, mtx[0] );
+ v3_muls( localplayer.rb.to_world[2], -1.0f, mtx[1] );
+ v3_muls( localplayer.rb.to_world[1], 1.0f, mtx[2] );
+ v3_muladds( localplayer.rb.to_world[3], localplayer.rb.to_world[1],
+ grind_radius + k_board_radius*0.25f+state->slap, mtx[3] );
+
+ rb_ct *cman = &manifold[manifold_len];
+
+ int l = rb_capsule__scene( mtx, &capsule, NULL, &world->rb_geo.inf.scene,
+ cman, k_material_flag_walking );
+
+ /* weld joints */
+ for( int i=0; i<l; i ++ )
+ cman[l].type = k_contact_type_edge;
+ rb_manifold_filter_joint_edges( cman, l, 0.03f );
+ l = rb_manifold_apply_filtered( cman, l );
+
+ manifold_len += l;
+
+ if( vg_lines.draw )
+ vg_line_capsule( mtx, capsule.radius, capsule.height, VG__WHITE );
+
+ /* add limits */
+ if( state->activity >= k_skate_activity_grind_any ){
+ for( int i=0; i<player_skate.limit_count; i++ ){
+ struct grind_limit *limit = &player_skate.limits[i];
+ rb_ct *ct = &manifold[ manifold_len ++ ];
+ m4x3_mulv( localplayer.rb.to_world, limit->ra, ct->co );
+ m3x3_mulv( localplayer.rb.to_world, limit->n, ct->n );
+ ct->p = limit->p;
+ ct->type = k_contact_type_default;
+ }
+ }
+
+ /*
+ * Phase 3: Dynamics
+ * --------------------------------------------------------------------------
+ */
+
+
+ v3f world_cog;
+ m4x3_mulv( localplayer.rb.to_world,
+ player_skate.weight_distribution, world_cog );
+ vg_line_point( world_cog, 0.02f, VG__BLACK );
+
+ for( int i=0; i<manifold_len; i ++ ){
+ rb_prepare_contact( &manifold[i], player_skate.substep_delta );
+ rb_debug_contact( &manifold[i] );
+ }
+
+ /* yes, we are currently rebuilding mass matrices every frame. too bad! */
+ v3f extent = { k_board_width, 0.1f, k_board_length };
+ float ex2 = k_board_interia*extent[0]*extent[0],
+ ey2 = k_board_interia*extent[1]*extent[1],
+ ez2 = k_board_interia*extent[2]*extent[2];
+
+ float mass = 2.0f * (extent[0]*extent[1]*extent[2]);
+ float inv_mass = 1.0f/mass;
+
+ v3f I;
+ I[0] = ((1.0f/12.0f) * mass * (ey2+ez2));
+ I[1] = ((1.0f/12.0f) * mass * (ex2+ez2));
+ I[2] = ((1.0f/12.0f) * mass * (ex2+ey2));
+
+ m3x3f iI;
+ m3x3_identity( iI );
+ iI[0][0] = I[0];
+ iI[1][1] = I[1];
+ iI[2][2] = I[2];
+ m3x3_inv( iI, iI );
+
+ m3x3f iIw;
+ m3x3_mul( iI, localplayer.rb.to_local, iIw );
+ m3x3_mul( localplayer.rb.to_world, iIw, iIw );
+
+ for( int j=0; j<10; j++ ){
+ for( int i=0; i<manifold_len; i++ ){
+ /*
+ * regular dance; calculate velocity & total mass, apply impulse.
+ */
+
+ struct contact *ct = &manifold[i];
+
+ v3f rv, delta;
+ v3_sub( ct->co, world_cog, delta );
+ v3_cross( localplayer.rb.w, delta, rv );
+ v3_add( localplayer.rb.v, rv, rv );
+
+ v3f raCn;
+ v3_cross( delta, ct->n, raCn );
+
+ v3f raCnI, rbCnI;
+ m3x3_mulv( iIw, raCn, raCnI );
+
+ float normal_mass = 1.0f / (inv_mass + v3_dot(raCn,raCnI)),
+ vn = v3_dot( rv, ct->n ),
+ lambda = normal_mass * ( -vn );
+
+ float temp = ct->norm_impulse;
+ ct->norm_impulse = vg_maxf( temp + lambda, 0.0f );
+ lambda = ct->norm_impulse - temp;
+
+ v3f impulse;
+ v3_muls( ct->n, lambda, impulse );
+
+ v3_muladds( normal_total, impulse, inv_mass, normal_total );
+ v3_muladds( localplayer.rb.v, impulse, inv_mass, localplayer.rb.v );
+ v3_cross( delta, impulse, impulse );
+ m3x3_mulv( iIw, impulse, impulse );
+ v3_add( impulse, localplayer.rb.w, localplayer.rb.w );
+
+ v3_cross( localplayer.rb.w, delta, rv );
+ v3_add( localplayer.rb.v, rv, rv );
+ vn = v3_dot( rv, ct->n );
+ }
+ }
+
+ v3f dt;
+ rb_depenetrate( manifold, manifold_len, dt );
+ v3_add( dt, localplayer.rb.co, localplayer.rb.co );
+ rb_update_transform( &localplayer.rb );
+
+ substep_count ++;
+
+ if( player_skate.substep >= 0.0001f )
+ goto begin_collision; /* again! */
+
+ /*
+ * End of collision and dynamics routine
+ * --------------------------------------------------------------------------
+ */
+
+ f32 nforce = v3_length(normal_total);
+ if( nforce > 4.0f ){
+ if( nforce > 17.6f ){
+ v3_muladds( localplayer.rb.v, normal_total, -1.0f, localplayer.rb.v );
+ player__dead_transition();
+ player__skate_kill_audio();
+ return;
+ }
+
+ f32 amt = k_cam_punch;
+ if( localplayer.cam_control.camera_mode == k_cam_firstperson ){
+ amt *= 0.25f;
+ }
+
+ v3_muladds( localplayer.cam_land_punch_v, normal_total, amt,
+ localplayer.cam_land_punch_v );
+ }
+
+ player_skate.surface = k_surface_prop_concrete;
+
+ for( int i=0; i<manifold_len; i++ ){
+ rb_ct *ct = &manifold[i];
+ struct world_surface *surf = world_contact_surface( world, ct );
+
+ if( surf->info.surface_prop > player_skate.surface )
+ player_skate.surface = surf->info.surface_prop;
+ }
+
+ for( int i=0; i<k_wheel_count; i++ ){
+ m4x3f mtx;
+ m3x3_copy( localplayer.rb.to_world, mtx );
+ m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, mtx[3] );
+ vg_line_sphere( mtx, wheels[i].radius,
+ (u32[]){ VG__WHITE, VG__BLACK,
+ wheels[i].colour }[ wheels[i].state ]);
+ }
+
+ skate_integrate();
+ vg_line_point( state->cog, 0.02f, VG__WHITE );
+
+ u32 id = world_intersect_gates( world, localplayer.rb.co, state->prev_pos );
+
+ if( id ){
+ ent_gate *gate = mdl_arritm( &world->ent_gate, mdl_entity_id_id(id) );
+
+ m4x3_mulv( gate->transport, localplayer.rb.co, localplayer.rb.co );
+ m3x3_mulv( gate->transport, localplayer.rb.v, localplayer.rb.v );
+ m4x3_mulv( gate->transport, state->cog, state->cog );
+ m3x3_mulv( gate->transport, state->cog_v, state->cog_v );
+ m3x3_mulv( gate->transport, state->throw_v, state->throw_v );
+ m3x3_mulv( gate->transport, state->head_position,
+ state->head_position );
+ m3x3_mulv( gate->transport, state->up_dir, state->up_dir );
+
+ v4f transport_rotation;
+ m3x3_q( gate->transport, transport_rotation );
+ q_mul( transport_rotation, localplayer.rb.q, localplayer.rb.q );
+ q_mul( transport_rotation, state->smoothed_rotation,
+ state->smoothed_rotation );
+ rb_update_transform( &localplayer.rb );
+ player__pass_gate( id );
+ }
+
+ /* FIXME: Rate limit */
+ static int stick_frames = 0;
+
+ if( state->activity >= k_skate_activity_ground )
+ stick_frames ++;
+ else
+ stick_frames = 0;
+
+ if( stick_frames > 5 ) stick_frames = 5;
+
+ if( stick_frames == 4 ){
+ if( state->activity == k_skate_activity_ground ){
+ if( (fabsf(state->slip) > 0.75f) ){
+ player__networked_sfx( k_player_subsystem_skate, 128,
+ k_player_skate_soundeffect_land_bad,
+ localplayer.rb.co, 0.6f );
+ }
+ else{
+ player__networked_sfx( k_player_subsystem_skate, 128,
+ k_player_skate_soundeffect_land_good,
+ localplayer.rb.co, 1.0f );
+ }
+ }
+ else if( player_skate.surface == k_surface_prop_metal ){
+ player__networked_sfx( k_player_subsystem_skate, 128,
+ k_player_skate_soundeffect_grind_metal,
+ localplayer.rb.co, 1.0f );
+ }
+ else{
+ player__networked_sfx( k_player_subsystem_skate, 128,
+ k_player_skate_soundeffect_grind_wood,
+ localplayer.rb.co, 1.0f );
+ }
+ } else if( stick_frames == 0 ){
+ /* TODO: EXIT SOUNDS */
+ }
+}
+
+static void player__skate_im_gui(void){
+ struct player_skate_state *state = &player_skate.state;
+ player__debugtext( 1, "V: %5.2f %5.2f %5.2f",localplayer.rb.v[0],
+ localplayer.rb.v[1],
+ localplayer.rb.v[2] );
+ player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",localplayer.rb.co[0],
+ localplayer.rb.co[1],
+ localplayer.rb.co[2] );
+ player__debugtext( 1, "W: %5.2f %5.2f %5.2f",localplayer.rb.w[0],
+ localplayer.rb.w[1],
+ localplayer.rb.w[2] );
+
+ const char *activity_txt[] = {
+ "air",
+ "air_to_grind",
+ "ground",
+ "undefined (INVALID)",
+ "grind_any (INVALID)",
+ "grind_boardslide",
+ "grind_metallic (INVALID)",
+ "grind_back50",
+ "grind_front50",
+ "grind_5050"
+ };
+
+ player__debugtext( 1, "activity: %s", activity_txt[state->activity] );
+#if 0
+ player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
+ state->steerx_s, state->steery_s,
+ k_steer_ground, k_steer_air );
+#endif
+ player__debugtext( 1, "flip: %.4f %.4f", state->flip_rate,
+ state->flip_time );
+ player__debugtext( 1, "trickv: %.2f %.2f %.2f",
+ state->trick_vel[0],
+ state->trick_vel[1],
+ state->trick_vel[2] );
+ player__debugtext( 1, "tricke: %.2f %.2f %.2f",
+ state->trick_euler[0],
+ state->trick_euler[1],
+ state->trick_euler[2] );
+}
+
+static void player__skate_animate(void){
+ struct player_skate_state *state = &player_skate.state;
+ struct player_skate_animator *animator = &player_skate.animator;
+
+ /* Head */
+ float kheight = 2.0f,
+ kleg = 0.6f;
+
+ v3_zero( animator->offset );
+
+ v3f cog_local, cog_ideal;
+ m4x3_mulv( localplayer.rb.to_local, state->cog, cog_local );
+
+ v3_copy( state->up_dir, cog_ideal );
+ v3_normalize( cog_ideal );
+ m3x3_mulv( localplayer.rb.to_local, cog_ideal, cog_ideal );
+
+ v3_sub( cog_ideal, cog_local, animator->offset );
+
+ v3_muls( animator->offset, 4.0f, animator->offset );
+ animator->offset[1] *= -1.0f;
+
+ float curspeed = v3_length( localplayer.rb.v ),
+ kickspeed = vg_clampf( curspeed*(1.0f/40.0f), 0.0f, 1.0f ),
+ kicks = (vg_randf64()-0.5f)*2.0f*kickspeed,
+ sign = vg_signf( kicks );
+
+ animator->wobble[0] = vg_lerpf( animator->wobble[0], kicks*kicks*sign,
+ 6.0f*vg.time_delta);
+ animator->wobble[1] = vg_lerpf( animator->wobble[1], animator->wobble[0],
+ 2.4f*vg.time_delta);
+
+ animator->offset[0] *= 0.26f;
+ animator->offset[0] += animator->wobble[1]*3.0f;
+
+ animator->offset[1] *= -0.3f;
+ animator->offset[2] *= 0.01f;
+
+ animator->offset[0]=vg_clampf(animator->offset[0],-0.8f,0.8f)*
+ (1.0f-fabsf(animator->slide)*0.9f);
+ animator->offset[1]=vg_clampf(animator->offset[1],-0.5f,0.0f);
+
+ v3f cam_offset;
+ v3_mul( animator->offset, (v3f){1.0f,0.3f,1.0f}, cam_offset );
+ v3_copy( cam_offset, localplayer.cam_control.tpv_offset_extra );
+
+ /* localized vectors */
+ m4x3_mulv( localplayer.rb.to_local, state->cog, animator->local_cog );
+
+ /*
+ * Animation blending
+ * ===========================================
+ */
+
+ /* sliding */
+ {
+ float desired = 0.0f;
+ if( state->activity == k_skate_activity_ground )
+ desired = vg_clampf( fabsf( state->slip ), 0.0f, 1.0f );
+
+ animator->slide = vg_lerpf( animator->slide, desired, 2.4f*vg.time_delta);
+ }
+
+ /* movement information */
+ int iair = state->activity <= k_skate_activity_air_to_grind;
+
+ float dirz = state->reverse > 0.0f? 0.0f: 1.0f,
+ dirx = state->slip < 0.0f? 0.0f: 1.0f,
+ fly = iair? 1.0f: 0.0f,
+ wdist= player_skate.weight_distribution[2] / k_board_length;
+
+ if( state->activity >= k_skate_activity_grind_any )
+ wdist = 0.0f;
+
+ animator->z = vg_lerpf( animator->z, dirz, 2.4f*vg.time_delta );
+ animator->x = vg_lerpf( animator->x, dirx, 0.6f*vg.time_delta );
+ animator->fly = vg_lerpf( animator->fly, fly, 3.4f*vg.time_delta );
+ animator->weight = vg_lerpf( animator->weight, wdist, 9.0f*vg.time_delta );
+
+ float stand = 1.0f - vg_clampf( curspeed * 0.03f, 0.0f, 1.0f );
+ animator->stand = vg_lerpf( animator->stand, stand, 6.0f*vg.time_delta );
+ animator->reverse = state->reverse;
+
+ if( fabsf(state->slip) > 0.3f ){
+ f32 slide_x = v3_dot(localplayer.rb.v, localplayer.rb.to_world[0]);
+ state->delayed_slip_dir = vg_signf(slide_x);
+ }
+
+ /* grinding */
+ f32 grind=state->activity >= k_skate_activity_grind_any? 1.0f: 0.0f;
+ animator->grind = vg_lerpf( animator->grind, grind, 5.0f*vg.time_delta );
+
+ f32 grind_frame = 0.5f;
+
+ if( state->activity == k_skate_activity_grind_front50 )
+ grind_frame = 0.0f;
+ else if( state->activity == k_skate_activity_grind_back50 )
+ grind_frame = 1.0f;
+
+ animator->grind_balance = vg_lerpf( animator->grind_balance, grind_frame,
+ 5.0f*vg.time_delta );
+
+ /* pushing */
+ animator->push_time = vg.time - state->start_push;
+ animator->push = vg_lerpf( animator->push,
+ (vg.time - state->cur_push) < 0.125,
+ 6.0f*vg.time_delta );
+
+ /* jumping */
+ animator->jump_charge = state->jump_charge;
+ animator->jump = vg_lerpf( animator->jump, animator->jump_charge,
+ 8.4f*vg.time_delta );
+
+ /* trick setup */
+ animator->jump_dir = state->jump_dir;
+ f32 jump_start_frame = 14.0f/30.0f;
+ animator->jump_time = animator->jump_charge * jump_start_frame;
+ f32 jump_frame = (vg.time - state->jump_time) + jump_start_frame;
+ if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
+ animator->jump_time = jump_frame;
+
+ /* trick */
+ float jump_t = vg.time-state->jump_time;
+ float k=17.0f;
+ float h = k*jump_t;
+ float extra = h*exp(1.0-h) * (state->jump_dir?1.0f:-1.0f);
+ extra *= state->slap * 4.0f;
+
+ v3_add( state->trick_euler, state->trick_residuald,
+ animator->board_euler );
+ v3_muls( animator->board_euler, VG_TAUf, animator->board_euler );
+
+ animator->board_euler[0] *= 0.5f;
+ animator->board_euler[1] += extra;
+ animator->trick_type = state->trick_type;
+
+ /* board lean */
+ f32 lean1, lean2 = animator->steer[0] * animator->reverse * -0.36f,
+ lean;
+
+ lean1 = animator->slide * animator->delayed_slip_dir;
+ if( fabsf(lean1)>fabsf(lean2) ) lean = lean1;
+ else lean = lean2;
+
+ if( ((int)roundf(animator->board_euler[0]/VG_PIf)) % 2 ) lean = -lean;
+ lean = vg_clampf( lean, -1.0f, 1.0f );
+ animator->board_lean =
+ vg_lerpf(animator->board_lean, lean, vg.time_delta*18.0f);
+
+ /* feet placement */
+ struct player_board *board =
+ addon_cache_item_if_loaded( k_addon_type_board,
+ localplayer.board_view_slot );
+ if( board ){
+ if( animator->weight > 0.0f ){
+ animator->foot_offset[0] =
+ board->truck_positions[k_board_truck_back][2]+0.3f;
+ }
+ else{
+ animator->foot_offset[1] =
+ board->truck_positions[k_board_truck_front][2]-0.3f;
+ }
+ }
+
+ f32 slapm = vg_maxf( 1.0f-v3_length2( state->trick_vel ), 0.0f );
+ animator->slap = state->slap;
+ animator->subslap = vg_lerpf( animator->subslap, slapm,
+ vg.time_delta*10.0f );
+
+ f32 l = ((state->activity < k_skate_activity_ground) &&
+ v3_length2(state->trick_vel) > 0.1f )? 1: 0;
+ animator->trick_foot = vg_lerpf( animator->trick_foot, l,
+ 8.4f*vg.time_delta );
+
+ /* grab */
+ v2f grab_input;
+ joystick_state( k_srjoystick_grab, grab_input );
+ v2_add( state->grab_mouse_delta, grab_input, grab_input );
+
+ if( v2_length2( grab_input ) <= 0.001f ) grab_input[0] = -1.0f;
+ else v2_normalize_clamp( grab_input );
+ v2_lerp( animator->grab, grab_input, 2.4f*vg.time_delta, animator->grab );
+ animator->grabbing = state->grabbing;
+
+ /* steer */
+ joystick_state( k_srjoystick_steer, animator->steer );
+
+ animator->airdir = vg_lerpf( animator->airdir, -animator->steer[0],
+ 2.4f*vg.time_delta );
+
+
+ /* flip angle */
+ if( (state->activity <= k_skate_activity_air_to_grind) &&
+ (fabsf(state->flip_rate) > 0.01f) ){
+ float substep = vg.time_fixed_extrapolate;
+ float t = state->flip_time+state->flip_rate*substep*k_rb_delta;
+ sign = vg_signf( t );
+
+ t = 1.0f - vg_minf( 1.0f, fabsf( t * 1.1f ) );
+ t = sign * (1.0f-t*t);
+
+ f32 angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf,
+ distm = state->land_dist * fabsf(state->flip_rate) * 3.0f,
+ blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
+ angle = vg_lerpf( angle, vg_signf(state->flip_rate)*VG_TAUf, blend );
+ q_axis_angle( animator->qflip, state->flip_axis, angle );
+ }
+ else
+ q_identity( animator->qflip );
+
+ /* counter-rotation */
+ if( v3_length2( state->up_dir ) > 0.001f ){
+ v4_lerp( state->smoothed_rotation, localplayer.rb.q,
+ 2.0f*vg.time_frame_delta,
+ state->smoothed_rotation );
+ q_normalize( state->smoothed_rotation );
+
+ v3f yaw_smooth = {1.0f,0.0f,0.0f};
+ q_mulv( state->smoothed_rotation, yaw_smooth, yaw_smooth );
+ m3x3_mulv( localplayer.rb.to_local, yaw_smooth, yaw_smooth );
+ yaw_smooth[1] = 0.0f;
+ v3_normalize( yaw_smooth );
+
+ f32 yaw_counter_rotate = yaw_smooth[0];
+ yaw_counter_rotate = vg_maxf( 0.7f, yaw_counter_rotate );
+ yaw_counter_rotate = acosf( yaw_counter_rotate );
+ yaw_counter_rotate *= 1.0f-animator->fly;
+
+ v3f ndir;
+ m3x3_mulv( localplayer.rb.to_local, state->up_dir, ndir );
+ v3_normalize( ndir );
+
+ v3f up = { 0.0f, 1.0f, 0.0f };
+ float a = v3_dot( ndir, up );
+ a = acosf( vg_clampf( a, -1.0f, 1.0f ) );
+
+ v3f axis;
+ v4f qcounteryaw, qfixup;
+
+ v3_cross( up, ndir, axis );
+ q_axis_angle( qfixup, axis, a*2.0f );
+
+ v3_cross( (v3f){1.0f,0.0f,0.0f}, yaw_smooth, axis );
+ q_axis_angle( qcounteryaw, axis, yaw_counter_rotate );
+
+ q_mul( qcounteryaw, qfixup, animator->qfixuptotal );
+ q_normalize( animator->qfixuptotal );
+
+ v3f p1, p2;
+ m3x3_mulv( localplayer.rb.to_world, up, p1 );
+ m3x3_mulv( localplayer.rb.to_world, ndir, p2 );
+
+ vg_line_arrow( localplayer.rb.co, p1, 0.5f, VG__PINK );
+ vg_line_arrow( localplayer.rb.co, p2, 0.5f, VG__PINK );
+ }
+ else q_identity( animator->qfixuptotal );
+ rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
+}
+
+static void player__skate_pose( void *_animator, player_pose *pose ){
+ struct skeleton *sk = &localplayer.skeleton;
+ struct player_skate_animator *animator = _animator;
+
+ pose->type = k_player_pose_type_ik;
+ v3_copy( animator->root_co, pose->root_co );
+ v4_copy( animator->root_q, pose->root_q );
+
+ /* transform */
+ v3f ext_up,ext_co;
+ q_mulv( pose->root_q, (v3f){0.0f,1.0f,0.0f}, ext_up );
+ v3_copy( pose->root_co, ext_co );
+ v3_muladds( pose->root_co, ext_up, -0.1f, pose->root_co );
+
+ /* apply flip rotation at midpoint */
+ q_mul( animator->qflip, pose->root_q, pose->root_q );
+ q_normalize( pose->root_q );
+
+ v3f rotation_point, rco;
+ v3_muladds( ext_co, ext_up, 0.5f, rotation_point );
+ v3_sub( pose->root_co, rotation_point, rco );
+
+ q_mulv( animator->qflip, rco, rco );
+ v3_add( rco, rotation_point, pose->root_co );
+
+ /* ANIMATIONS
+ * ---------------------------------------------------------------------- */
+
+ mdl_keyframe apose[32], bpose[32];
+ mdl_keyframe ground_pose[32];
+ {
+ /* stand/crouch */
+ f32 dir_frame = animator->z * (15.0f/30.0f),
+ stand_blend = animator->offset[1]*-2.0f;
+
+ pose->board.lean = animator->board_lean;
+
+ stand_blend = vg_clampf( 1.0f-animator->local_cog[1], 0, 1 );
+
+ skeleton_sample_anim( sk, player_skate.anim_stand, dir_frame, apose );
+ skeleton_sample_anim( sk, player_skate.anim_highg, dir_frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
+
+ /* sliding */
+ skeleton_sample_anim( sk, player_skate.anim_slide, animator->x * 0.5f,
+ bpose );
+ skeleton_lerp_pose( sk, apose, bpose, animator->slide, apose );
+
+ if( animator->reverse > 0.0f ){
+ skeleton_sample_anim( sk, player_skate.anim_push, animator->push_time,
+ bpose );
+ }
+ else{
+ skeleton_sample_anim( sk, player_skate.anim_push_reverse,
+ animator->push_time, bpose );
+ }
+ skeleton_lerp_pose( sk, apose, bpose, animator->push, apose );
+
+ struct skeleton_anim *jump_anim = animator->jump_dir?
+ player_skate.anim_ollie:
+ player_skate.anim_ollie_reverse;
+
+ f32 setup_blend = vg_minf( animator->jump, 1.0f );
+ skeleton_sample_anim_clamped( sk, jump_anim, animator->jump_time, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
+ }
+
+ mdl_keyframe air_pose[32];
+ {
+ float air_frame = (animator->airdir*0.5f+0.5f) * (15.0f/30.0f);
+ skeleton_sample_anim( sk, player_skate.anim_air, air_frame, apose );
+
+ float ang = atan2f( animator->grab[0], animator->grab[1] ),
+ ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
+ grab_frame = ang_unit * (15.0f/30.0f);
+
+ skeleton_sample_anim( sk, player_skate.anim_grabs, grab_frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, animator->grabbing, air_pose );
+ }
+
+ skeleton_lerp_pose( sk, ground_pose, air_pose, animator->fly,
+ pose->keyframes );
+
+ mdl_keyframe *kf_board = &pose->keyframes[localplayer.id_board-1],
+ *kf_foot_l = &pose->keyframes[localplayer.id_ik_foot_l-1],
+ *kf_foot_r = &pose->keyframes[localplayer.id_ik_foot_r-1],
+ *kf_knee_l = &pose->keyframes[localplayer.id_ik_knee_l-1],
+ *kf_knee_r = &pose->keyframes[localplayer.id_ik_knee_r-1],
+ *kf_hip = &pose->keyframes[localplayer.id_hip-1],
+ *kf_wheels[] = { &pose->keyframes[localplayer.id_wheel_r-1],
+ &pose->keyframes[localplayer.id_wheel_l-1] };
+
+
+ mdl_keyframe grind_pose[32];
+ {
+ f32 frame = animator->grind_balance * 0.5f;
+
+ skeleton_sample_anim( sk, player_skate.anim_grind, frame, apose );
+ skeleton_sample_anim( sk, player_skate.anim_grind_jump, frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, animator->jump, grind_pose );
+ }
+ skeleton_lerp_pose( sk, pose->keyframes, grind_pose,
+ animator->grind, pose->keyframes );
+ float add_grab_mod = 1.0f - animator->fly;
+
+ /* additive effects */
+ u32 apply_to[] = { localplayer.id_hip,
+ localplayer.id_ik_hand_l,
+ localplayer.id_ik_hand_r,
+ localplayer.id_ik_elbow_l,
+ localplayer.id_ik_elbow_r };
+
+ float apply_rates[] = { 1.0f,
+ 0.75f,
+ 0.75f,
+ 0.75f,
+ 0.75f };
+
+ for( int i=0; i<vg_list_size(apply_to); i ++ ){
+ pose->keyframes[apply_to[i]-1].co[0] += animator->offset[0]*add_grab_mod;
+ pose->keyframes[apply_to[i]-1].co[2] += animator->offset[2]*add_grab_mod;
+ }
+
+ /* angle 'correction' */
+ v3f origin;
+ v3_add( sk->bones[localplayer.id_hip].co, kf_hip->co, origin );
+
+ for( int i=0; i<vg_list_size(apply_to); i ++ ){
+ mdl_keyframe *kf = &pose->keyframes[apply_to[i]-1];
+ keyframe_rotate_around( kf, origin, sk->bones[apply_to[i]].co,
+ animator->qfixuptotal );
+ }
+
+ /* trick rotation */
+ v4f qtrick, qyaw, qpitch, qroll;
+ q_axis_angle( qyaw, (v3f){0.0f,1.0f,0.0f}, animator->board_euler[0] );
+ q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, animator->board_euler[1] );
+ q_axis_angle( qroll, (v3f){0.0f,0.0f,1.0f}, animator->board_euler[2] );
+
+ q_mul( qyaw, qroll, qtrick );
+ q_mul( qpitch, qtrick, qtrick );
+ q_mul( kf_board->q, qtrick, kf_board->q );
+ q_normalize( kf_board->q );
+
+ kf_foot_l->co[2] = vg_lerpf( kf_foot_l->co[2], animator->foot_offset[0],
+ 0.5f * animator->weight );
+ kf_foot_r->co[2] = vg_lerpf( kf_foot_r->co[2], animator->foot_offset[1],
+ -0.5f * animator->weight );
+
+ kf_foot_l->co[1] += animator->slap;
+ kf_foot_r->co[1] += animator->slap;
+ kf_knee_l->co[1] += animator->slap;
+ kf_knee_r->co[1] += animator->slap;
+ kf_board->co[1] += animator->slap * animator->subslap;
+ kf_hip->co[1] += animator->slap * 0.25f;
+
+ if( animator->trick_type == k_trick_type_kickflip ){
+ kf_foot_l->co[0] += animator->trick_foot * 0.2f;
+ kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
+ }
+ else if( animator->trick_type == k_trick_type_shuvit ){
+ kf_foot_l->co[0] += animator->trick_foot * 0.1f;
+ kf_foot_r->co[0] -= animator->trick_foot * 0.15f;
+ kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
+ kf_foot_r->co[1] -= animator->trick_foot * 0.18f;
+ }
+ else if( animator->trick_type == k_trick_type_treflip ){
+ kf_foot_l->co[0] += animator->trick_foot * 0.2f;
+ kf_foot_r->co[0] -= animator->trick_foot * 0.15f;
+ kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
+ kf_foot_r->co[1] -= animator->trick_foot * 0.18f;
+ }
+
+ /*
+ * animation wishlist:
+ * boardslide/grind jump animations
+ * when tricking the slap should not appply or less apply
+ * not animations however DONT target grinds that are vertically down.
+ */
+
+ /* truck rotation */
+ for( int i=0; i<2; i++ ){
+ float a = vg_minf( player_skate.truckv0[i][0], 1.0f );
+ a = -acosf( a ) * vg_signf( player_skate.truckv0[i][1] );
+
+ v4f q;
+ q_axis_angle( q, (v3f){0.0f,0.0f,1.0f}, a );
+ q_mul( q, kf_wheels[i]->q, kf_wheels[i]->q );
+ q_normalize( kf_wheels[i]->q );
+ }
+
+ {
+ mdl_keyframe
+ *kf_head = &pose->keyframes[localplayer.id_head-1],
+ *kf_elbow_l = &pose->keyframes[localplayer.id_ik_elbow_l-1],
+ *kf_elbow_r = &pose->keyframes[localplayer.id_ik_elbow_r-1],
+ *kf_hand_l = &pose->keyframes[localplayer.id_ik_hand_l-1],
+ *kf_hand_r = &pose->keyframes[localplayer.id_ik_hand_r-1];
+
+ float warble = perlin1d( vg.time, 2.0f, 2, 300 );
+ warble *= vg_maxf(animator->grind, fabsf(animator->weight)) * 0.3f;
+
+ v4f qrot;
+ q_axis_angle( qrot, (v3f){0.8f,0.7f,0.6f}, warble );
+
+ v3f origin = {0.0f,0.2f,0.0f};
+ keyframe_rotate_around( kf_hand_l, origin,
+ sk->bones[localplayer.id_ik_hand_l].co, qrot );
+ keyframe_rotate_around( kf_hand_r, origin,
+ sk->bones[localplayer.id_ik_hand_r].co, qrot );
+ keyframe_rotate_around( kf_hip, origin,
+ sk->bones[localplayer.id_hip].co, qrot );
+ keyframe_rotate_around( kf_elbow_r, origin,
+ sk->bones[localplayer.id_ik_elbow_r].co, qrot );
+ keyframe_rotate_around( kf_elbow_l, origin,
+ sk->bones[localplayer.id_ik_elbow_l].co, qrot );
+
+ q_inv( qrot, qrot );
+ q_mul( qrot, kf_head->q, kf_head->q );
+ q_normalize( kf_head->q );
+ }
+}
+
+static void player__skate_post_animate(void){
+ struct player_skate_state *state = &player_skate.state;
+ localplayer.cam_velocity_influence = 1.0f;
+
+ v3f head = { 0.0f, 1.8f, 0.0f };
+ m4x3_mulv( localplayer.final_mtx[ localplayer.id_head ],
+ head, state->head_position );
+ m4x3_mulv( localplayer.rb.to_local,
+ state->head_position, state->head_position );
+}
+
+static void player__skate_reset_animator(void){
+ struct player_skate_state *state = &player_skate.state;
+
+ memset( &player_skate.animator, 0, sizeof(player_skate.animator) );
+
+ if( state->activity <= k_skate_activity_air_to_grind )
+ player_skate.animator.fly = 1.0f;
+ else
+ player_skate.animator.fly = 0.0f;
+}
+
+static void player__skate_clear_mechanics(void){
+ struct player_skate_state *state = &player_skate.state;
+ state->jump_charge = 0.0f;
+ state->charging_jump = 0;
+ state->jump_dir = 0;
+ v3_zero( state->flip_axis );
+ state->flip_time = 0.0f;
+ state->flip_rate = 0.0f;
+ state->reverse = 0.0f;
+ state->slip = 0.0f;
+ state->grabbing = 0.0f;
+ v2_zero( state->grab_mouse_delta );
+ state->slap = 0.0f;
+ state->jump_time = 0.0;
+ state->start_push = 0.0;
+ state->cur_push = 0.0;
+ state->air_start = 0.0;
+
+ v3_zero( state->air_init_v );
+ v3_zero( state->air_init_co );
+
+ state->gravity_bias = k_gravity;
+ v3_copy( localplayer.rb.co, state->prev_pos );
+ v4_copy( localplayer.rb.q, state->smoothed_rotation );
+ v3_zero( state->throw_v );
+ v3_zero( state->trick_vel );
+ v3_zero( state->trick_euler );
+ v3_zero( state->cog_v );
+ state->grind_cooldown = 0;
+ state->surface_cooldown = 0;
+ v3_muladds( localplayer.rb.co, localplayer.rb.to_world[1], 1.0f, state->cog );
+ v3_copy( localplayer.rb.to_world[1], state->up_dir );
+ v3_copy( localplayer.rb.to_world[1], player_skate.surface_picture );
+ v3_copy( localplayer.rb.co, state->prev_pos );
+ v3_zero( player_skate.weight_distribution );
+}
+
+#include "network_compression.h"
+
+static void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
+ struct player_skate_animator *animator = data;
+
+ bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
+ bitpack_qquat( ctx, animator->root_q );
+
+ bitpack_qv3f( ctx, 8, -1.0f, 1.0f, animator->offset );
+ bitpack_qv3f( ctx, 8, -1.0f, 1.0f, animator->local_cog );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->slide );
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->z );
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->x );
+
+ /* these could likely be pressed down into single bits if needed */
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->fly );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->grind );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->stand );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->push );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->jump ); /*??*/
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->jump_charge ); /*??*/
+
+ /* just the sign bit? */
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->reverse );
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->delayed_slip_dir );
+ bitpack_bytes( ctx, 1, &animator->jump_dir );
+ bitpack_bytes( ctx, 1, &animator->trick_type );
+
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->grind_balance );
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->airdir );
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->weight );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->trick_foot );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->slap );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->subslap );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->grabbing );
+
+ /* animator->wobble is ommited */
+
+ bitpack_qv2f( ctx, 8, -1.0f, 1.0f, animator->foot_offset );
+ bitpack_qquat( ctx, animator->qfixuptotal );
+ bitpack_qquat( ctx, animator->qflip );
+
+ bitpack_qv3f( ctx, 16, -100.0f, 100.0f, animator->board_euler );
+ bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->board_lean );
+ bitpack_qv2f( ctx, 8, -1.0f, 1.0f, animator->steer );
+ bitpack_qv2f( ctx, 8, -1.0f, 1.0f, animator->grab );
+
+ bitpack_qf32( ctx, 16, 0.0f, 120.0f, &animator->push_time );
+ bitpack_qf32( ctx, 16, 0.0f, 120.0f, &animator->jump_time );
+}
+
+static void player__skate_sfx_oneshot( u8 id, v3f pos, f32 volume ){
+ audio_lock();
+
+ if( id == k_player_skate_soundeffect_jump ){
+ audio_oneshot_3d( &audio_jumps[vg_randu32()%2], pos, 40.0f, volume );
+ }
+ else if( id == k_player_skate_soundeffect_tap ){
+ audio_oneshot_3d( &audio_taps[vg_randu32()%4], pos, 40.0f, volume );
+ }
+ else if( id == k_player_skate_soundeffect_land_good ){
+ audio_oneshot_3d( &audio_lands[vg_randu32()%3], pos, 40.0f, volume );
+ }
+ else if( id == k_player_skate_soundeffect_land_bad ){
+ audio_oneshot_3d( &audio_lands[vg_randu32()%2+3], pos, 40.0f, volume );
+ }
+ else if( id == k_player_skate_soundeffect_grind_metal ){
+ audio_oneshot_3d( &audio_board[3], pos, 40.0f, volume );
+ }
+ else if( id == k_player_skate_soundeffect_grind_wood ){
+ audio_oneshot_3d( &audio_board[8], pos, 40.0f, volume );
+ }
+
+ audio_unlock();
+}