+ v4_copy( player->rb.q, future_q );
+
+ v3f future_cg, current_cg, cg_offset;
+ q_mulv( player->rb.q, s->weight_distribution, current_cg );
+ q_mulv( future_q, s->weight_distribution, future_cg );
+ v3_sub( future_cg, current_cg, cg_offset );
+
+ /* calculate the minimum time we can move */
+ float max_time = s->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( player->rb.q, wheels[i].pos, current );
+ v3_add( current, player->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 * s->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 );
+ s->substep_delta = max_time;
+
+ /* integrate */
+ v3_muladds( player->rb.co, player->rb.v, s->substep_delta, player->rb.co );
+ if( v3_length2( player->rb.w ) > 0.0f ){
+ v4f rotation;
+ v3f axis;
+ v3_copy( player->rb.w, axis );
+
+ float mag = v3_length( axis );
+ v3_divs( axis, mag, axis );
+ q_axis_angle( rotation, axis, mag*s->substep_delta );
+ q_mul( rotation, player->rb.q, player->rb.q );
+ q_normalize( player->rb.q );
+
+ q_mulv( player->rb.q, s->weight_distribution, future_cg );
+ v3_sub( current_cg, future_cg, cg_offset );
+ v3_add( player->rb.co, cg_offset, player->rb.co );
+ }
+
+ rb_update_transform( &player->rb );
+ v3_muladds( player->rb.v, player->basis[1],
+ -s->state.gravity_bias * s->substep_delta, player->rb.v );
+
+ s->substep -= s->substep_delta;
+
+ rb_ct manifold[128];
+ int manifold_len = 0;
+ /*
+ * Phase -1: head detection
+ * --------------------------------------------------------------------------
+ */
+ m4x3_mulv( player->rb.to_world, s->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, player->rb.co, t, player->rb.co );
+ rb_update_transform( &player->rb );
+
+ player__skate_kill_audio( player );
+ player__dead_transition( player );
+ 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( player->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( player, 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( player->rb.to_world[0], 1.0f, mtx[0] );
+ v3_muls( player->rb.to_world[2], -1.0f, mtx[1] );
+ v3_muls( player->rb.to_world[1], 1.0f, mtx[2] );
+ v3_muladds( player->rb.to_world[3], player->rb.to_world[1],
+ grind_radius + k_board_radius*0.25f+s->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( s->state.activity >= k_skate_activity_grind_any ){
+ for( int i=0; i<s->limit_count; i++ ){
+ struct grind_limit *limit = &s->limits[i];
+ rb_ct *ct = &manifold[ manifold_len ++ ];
+ m4x3_mulv( player->rb.to_world, limit->ra, ct->co );
+ m3x3_mulv( player->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( player->rb.to_world, s->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], s->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, player->rb.to_local, iIw );
+ m3x3_mul( player->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( player->rb.w, delta, rv );
+ v3_add( player->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( player->rb.v, impulse, inv_mass, player->rb.v );
+ v3_cross( delta, impulse, impulse );
+ m3x3_mulv( iIw, impulse, impulse );
+ v3_add( impulse, player->rb.w, player->rb.w );
+
+ v3_cross( player->rb.w, delta, rv );
+ v3_add( player->rb.v, rv, rv );
+ vn = v3_dot( rv, ct->n );
+ }
+ }
+
+ v3f dt;
+ rb_depenetrate( manifold, manifold_len, dt );
+ v3_add( dt, player->rb.co, player->rb.co );
+ rb_update_transform( &player->rb );
+
+ substep_count ++;
+
+ if( s->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( player->rb.v, normal_total, -1.0f, player->rb.v );
+ player__dead_transition(player);
+ player__skate_kill_audio(player);
+ return;
+ }
+
+ f32 amt = k_cam_punch;
+ if( player->cam_control.camera_mode == k_cam_firstperson ){
+ amt *= 0.25f;
+ }
+
+ v3_muladds( player->cam_land_punch_v, normal_total, amt,
+ player->cam_land_punch_v );
+ }
+
+ s->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 > s->surface )
+ s->surface = surf->info.surface_prop;
+ }
+
+ for( int i=0; i<k_wheel_count; i++ ){
+ m4x3f mtx;
+ m3x3_copy( player->rb.to_world, mtx );
+ m4x3_mulv( player->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( player );
+ vg_line_point( s->state.cog, 0.02f, VG__WHITE );
+
+ ent_gate *gate =
+ world_intersect_gates(world, player->rb.co, s->state.prev_pos );
+
+ if( gate ){
+ m4x3_mulv( gate->transport, player->rb.co, player->rb.co );
+ m3x3_mulv( gate->transport, player->rb.v, player->rb.v );
+ m4x3_mulv( gate->transport, s->state.cog, s->state.cog );
+ m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
+ m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
+ m3x3_mulv( gate->transport, s->state.head_position,
+ s->state.head_position );
+ m3x3_mulv( gate->transport, s->state.up_dir, s->state.up_dir );
+
+ v4f transport_rotation;
+ m3x3_q( gate->transport, transport_rotation );
+ q_mul( transport_rotation, player->rb.q, player->rb.q );
+ q_mul( transport_rotation, s->state.smoothed_rotation,
+ s->state.smoothed_rotation );
+ rb_update_transform( &player->rb );
+ player__pass_gate( player, gate );
+ }
+
+ /* FIXME: Rate limit */
+ static int stick_frames = 0;
+
+ if( s->state.activity >= k_skate_activity_ground )
+ stick_frames ++;
+ else
+ stick_frames = 0;
+
+ if( stick_frames > 5 ) stick_frames = 5;
+
+ if( stick_frames == 4 ){
+ audio_lock();
+
+ if( s->state.activity == k_skate_activity_ground ){
+ if( (fabsf(s->state.slip) > 0.75f) ){
+ audio_oneshot_3d( &audio_lands[vg_randu32()%2+3], player->rb.co,
+ 40.0f, 1.0f );
+ }
+ else{
+ audio_oneshot_3d( &audio_lands[vg_randu32()%3], player->rb.co,
+ 40.0f, 1.0f );
+ }
+ }
+ else if( s->surface == k_surface_prop_metal ){
+ audio_oneshot_3d( &audio_board[3], player->rb.co, 40.0f, 1.0f );
+ }
+ else{
+ audio_oneshot_3d( &audio_board[8], player->rb.co, 40.0f, 1.0f );
+ }
+
+ audio_unlock();
+ } else if( stick_frames == 0 ){
+
+ }
+}
+
+VG_STATIC void player__skate_im_gui( player_instance *player ){
+ struct player_skate *s = &player->_skate;
+ player__debugtext( 1, "V: %5.2f %5.2f %5.2f",player->rb.v[0],
+ player->rb.v[1],
+ player->rb.v[2] );
+ player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",player->rb.co[0],
+ player->rb.co[1],
+ player->rb.co[2] );
+ player__debugtext( 1, "W: %5.2f %5.2f %5.2f",player->rb.w[0],
+ player->rb.w[1],
+ player->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[s->state.activity] );
+#if 0
+ player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
+ s->state.steerx_s, s->state.steery_s,
+ k_steer_ground, k_steer_air );
+#endif
+ player__debugtext( 1, "flip: %.4f %.4f", s->state.flip_rate,
+ s->state.flip_time );
+ player__debugtext( 1, "trickv: %.2f %.2f %.2f",
+ s->state.trick_vel[0],
+ s->state.trick_vel[1],
+ s->state.trick_vel[2] );
+ player__debugtext( 1, "tricke: %.2f %.2f %.2f",
+ s->state.trick_euler[0],
+ s->state.trick_euler[1],
+ s->state.trick_euler[2] );
+}
+
+VG_STATIC void player__skate_animate( player_instance *player ){
+ struct player_skate *s = &player->_skate;
+ struct player_skate_state *state = &player->_skate.state;
+ struct player_skate_animator *animator = &s->animator;
+
+ /* Head */
+ float kheight = 2.0f,
+ kleg = 0.6f;
+
+ v3_zero( animator->offset );
+
+ v3f cog_local, cog_ideal;
+ m4x3_mulv( player->rb.to_local, s->state.cog, cog_local );
+
+ v3_copy( s->state.up_dir, cog_ideal );
+ v3_normalize( cog_ideal );
+ m3x3_mulv( player->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( player->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);
+
+ v3_muls( animator->offset, 0.3f, player->cam_control.tpv_offset_extra );
+
+ /* localized vectors */
+ m4x3_mulv( player->rb.to_local, s->state.cog, animator->local_cog );
+
+ /*
+ * Animation blending
+ * ===========================================
+ */
+
+ /* sliding */
+ {
+ float desired = 0.0f;
+ if( s->state.activity == k_skate_activity_ground )
+ desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f );
+
+ animator->slide = vg_lerpf( animator->slide, desired, 2.4f*vg.time_delta);
+ }
+
+ /* movement information */
+ int iair = s->state.activity <= k_skate_activity_air_to_grind;
+
+ float dirz = s->state.reverse > 0.0f? 0.0f: 1.0f,
+ dirx = s->state.slip < 0.0f? 0.0f: 1.0f,
+ fly = iair? 1.0f: 0.0f,
+ wdist= s->weight_distribution[2] / k_board_length;
+
+ if( s->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 = s->state.reverse;
+
+ if( fabsf(s->state.slip) > 0.3f ){
+ f32 slide_dir = vg_signf(v3_dot(player->rb.v,player->rb.to_world[0]));
+ s->state.delayed_slip_dir = slide_dir;
+ }
+
+ /* grinding */
+ f32 grind=s->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( s->state.activity == k_skate_activity_grind_front50 )
+ grind_frame = 0.0f;
+ else if( s->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 - s->state.start_push;
+ animator->push = vg_lerpf( animator->push,
+ (vg.time - s->state.cur_push) < 0.125,
+ 6.0f*vg.time_delta );
+
+ /* jumping */
+ animator->jump_charge = s->state.jump_charge;
+ animator->jump = vg_lerpf( animator->jump, animator->jump_charge,
+ 8.4f*vg.time_delta );
+
+ /* trick setup */
+ animator->jump_dir = s->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 - s->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-s->state.jump_time;
+ float k=17.0f;
+ float h = k*jump_t;
+ float extra = h*exp(1.0-h) * (s->state.jump_dir?1.0f:-1.0f);
+ extra *= s->state.slap * 4.0f;
+
+ v3_add( s->state.trick_euler, s->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 = s->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,
+ player->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( s->state.trick_vel ), 0.0f );
+ animator->slap = s->state.slap;
+ animator->subslap = vg_lerpf( animator->subslap, slapm,
+ vg.time_delta*10.0f );
+
+ f32 l = ((s->state.activity < k_skate_activity_ground) &&
+ v3_length2(s->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( s->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 = s->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( (s->state.activity <= k_skate_activity_air_to_grind) &&
+ (fabsf(s->state.flip_rate) > 0.01f) ){
+ float substep = vg.time_fixed_extrapolate;
+ float t = s->state.flip_time+s->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 = s->state.land_dist * fabsf(s->state.flip_rate) * 3.0f,
+ blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
+ angle = vg_lerpf( angle, vg_signf(s->state.flip_rate)*VG_TAUf, blend );
+ q_axis_angle( animator->qflip, s->state.flip_axis, angle );
+ }
+ else
+ q_identity( animator->qflip );
+
+ /* counter-rotation */
+ if( v3_length2( s->state.up_dir ) > 0.001f ){
+ v4_lerp( s->state.smoothed_rotation, player->rb.q,
+ 2.0f*vg.time_frame_delta,
+ s->state.smoothed_rotation );
+ q_normalize( s->state.smoothed_rotation );
+
+ v3f yaw_smooth = {1.0f,0.0f,0.0f};
+ q_mulv( s->state.smoothed_rotation, yaw_smooth, yaw_smooth );
+ m3x3_mulv( player->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( player->rb.to_local, s->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( player->rb.to_world, up, p1 );
+ m3x3_mulv( player->rb.to_world, ndir, p2 );
+
+ vg_line_arrow( player->rb.co, p1, 0.5f, VG__PINK );
+ vg_line_arrow( player->rb.co, p2, 0.5f, VG__PINK );
+ }
+ else q_identity( animator->qfixuptotal );
+ rb_extrapolate( &player->rb, animator->root_co, animator->root_q );
+}
+
+VG_STATIC void player__skate_pose( player_instance *player, player_pose *pose ){
+ struct player_avatar *av = player->playeravatar;
+ struct skeleton *sk = &av->sk;
+ struct player_skate *s = &player->_skate;
+ struct player_skate_animator *animator = &s->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, s->anim_stand, dir_frame, apose );
+ skeleton_sample_anim( sk, s->anim_highg, dir_frame, bpose );
+ skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
+
+ /* sliding */
+ skeleton_sample_anim( sk, s->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, s->anim_push, animator->push_time, bpose );
+ else{
+ skeleton_sample_anim( sk, s->anim_push_reverse, animator->push_time,
+ bpose );
+ }
+ skeleton_lerp_pose( sk, apose, bpose, animator->push, apose );
+
+ struct skeleton_anim *jump_anim = animator->jump_dir?
+ s->anim_ollie:
+ s->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, s->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, s->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[av->id_board-1],
+ *kf_foot_l = &pose->keyframes[av->id_ik_foot_l-1],
+ *kf_foot_r = &pose->keyframes[av->id_ik_foot_r-1],
+ *kf_knee_l = &pose->keyframes[av->id_ik_knee_l-1],
+ *kf_knee_r = &pose->keyframes[av->id_ik_knee_r-1],
+ *kf_hip = &pose->keyframes[av->id_hip-1],
+ *kf_wheels[] = { &pose->keyframes[av->id_wheel_r-1],
+ &pose->keyframes[av->id_wheel_l-1] };
+
+
+ mdl_keyframe grind_pose[32];
+ {
+ f32 frame = animator->grind_balance * 0.5f;
+
+ skeleton_sample_anim( sk, s->anim_grind, frame, apose );
+ skeleton_sample_anim( sk, s->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[] = { av->id_hip,
+ av->id_ik_hand_l,
+ av->id_ik_hand_r,
+ av->id_ik_elbow_l,
+ av->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( av->sk.bones[av->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, av->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( s->truckv0[i][0], 1.0f );
+ a = -acosf( a ) * vg_signf( s->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 );
+ }
+
+#if 0
+ {
+ mdl_keyframe
+ *kf_head = &pose->keyframes[av->id_head-1],
+ *kf_elbow_l = &pose->keyframes[av->id_ik_elbow_l-1],
+ *kf_elbow_r = &pose->keyframes[av->id_ik_elbow_r-1],
+ *kf_hand_l = &pose->keyframes[av->id_ik_hand_l-1],
+ *kf_hand_r = &pose->keyframes[av->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,
+ av->sk.bones[av->id_ik_hand_l].co, qrot );
+ keyframe_rotate_around( kf_hand_r, origin,
+ av->sk.bones[av->id_ik_hand_r].co, qrot );
+ keyframe_rotate_around( kf_hip, origin,
+ av->sk.bones[av->id_hip].co, qrot );
+ keyframe_rotate_around( kf_elbow_r, origin,
+ av->sk.bones[av->id_ik_elbow_r].co, qrot );
+ keyframe_rotate_around( kf_elbow_l, origin,
+ av->sk.bones[av->id_ik_elbow_l].co, qrot );
+
+ q_inv( qrot, qrot );
+ q_mul( qrot, kf_head->q, kf_head->q );
+ q_normalize( kf_head->q );
+ }
+#endif
+}
+
+VG_STATIC void player__skate_post_animate( player_instance *player )
+{
+ struct player_skate *s = &player->_skate;
+ struct player_avatar *av = player->playeravatar;
+
+ player->cam_velocity_influence = 1.0f;
+
+ v3f head = { 0.0f, 1.8f, 0.0f };
+ m4x3_mulv( av->sk.final_mtx[ av->id_head ], head, s->state.head_position );
+ m4x3_mulv( player->rb.to_local, s->state.head_position,
+ s->state.head_position );
+}
+
+VG_STATIC void player__skate_reset_animator( player_instance *player ){
+ struct player_skate *s = &player->_skate;
+ struct player_skate_state *state = &s->state;
+
+ memset( &s->animator, 0, sizeof(s->animator) );
+
+ if( s->state.activity <= k_skate_activity_air_to_grind )
+ s->animator.fly = 1.0f;
+ else
+ s->animator.fly = 0.0f;
+}
+
+VG_STATIC void player__skate_clear_mechanics( player_instance *player )
+{
+ struct player_skate *s = &player->_skate;
+ s->state.jump_charge = 0.0f;
+ s->state.charging_jump = 0;
+ s->state.jump_dir = 0;
+ v3_zero( s->state.flip_axis );
+ s->state.flip_time = 0.0f;
+ s->state.flip_rate = 0.0f;
+ s->state.reverse = 0.0f;
+ s->state.slip = 0.0f;
+ s->state.grabbing = 0.0f;
+ v2_zero( s->state.grab_mouse_delta );
+ s->state.slap = 0.0f;
+ s->state.jump_time = 0.0;
+ s->state.start_push = 0.0;
+ s->state.cur_push = 0.0;
+ s->state.air_start = 0.0;
+
+ v3_zero( s->state.air_init_v );
+ v3_zero( s->state.air_init_co );
+
+ s->state.gravity_bias = k_gravity;
+ v3_copy( player->rb.co, s->state.prev_pos );
+ v4_copy( player->rb.q, s->state.smoothed_rotation );
+ v3_zero( s->state.throw_v );
+ v3_zero( s->state.trick_vel );
+ v3_zero( s->state.trick_euler );
+ v3_zero( s->state.cog_v );
+ s->state.grind_cooldown = 0;
+ s->state.surface_cooldown = 0;
+ v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
+ v3_copy( player->rb.to_world[1], s->state.up_dir );
+ v3_copy( player->rb.to_world[1], s->surface_picture );
+ v3_zero( s->weight_distribution );
+ v3_copy( player->rb.co, s->state.prev_pos );
+}
+
+VG_STATIC void player__skate_reset( player_instance *player,
+ ent_spawn *rp )
+{
+ struct player_skate *s = &player->_skate;
+ v3_zero( player->rb.v );
+ v4_copy( rp->transform.q, player->rb.q );
+
+ s->state.activity = k_skate_activity_air;
+ s->state.activity_prev = k_skate_activity_air;
+
+ player__skate_clear_mechanics( player );
+ player__skate_reset_animator( player );
+
+ v3_zero( s->state.head_position );
+ s->state.head_position[1] = 1.8f;