+ /* 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
+ * ---------------------------------------------------------------------- */
+