X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_skate.c;h=fcaffd9e9466b550b1977e44e09c3776bef10e2a;hb=5bfb36032928ba9f8d12e72961af68bfab9ea648;hp=1ef19a1b6af6d67bdbddc6ebcc634f118d683803;hpb=9eb3de757a997becb8406417a4bf613f4cb04900;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/player_skate.c b/player_skate.c index 1ef19a1..fcaffd9 100644 --- a/player_skate.c +++ b/player_skate.c @@ -59,18 +59,17 @@ VG_STATIC int skate_collide_smooth( player_instance *player, world_instance *world = world_current_instance(); int len = 0; - len = rb_sphere__scene( mtx, sphere, NULL, &world->rb_geo.inf.scene, man ); + len = rb_sphere__scene( mtx, sphere, NULL, &world->rb_geo.inf.scene, man, + k_material_flag_walking ); - for( int i=0; irb; man[i].rbb = NULL; } rb_manifold_filter_coplanar( man, len, 0.03f ); - if( len > 1 ) - { + if( len > 1 ){ rb_manifold_filter_backface( man, len ); rb_manifold_filter_joint_edges( man, len, 0.03f ); rb_manifold_filter_pairs( man, len, 0.03f ); @@ -499,8 +498,8 @@ void player__approximate_best_trajectory( player_instance *player ) m4x3_mulv( gate->transport, launch_co, launch_co ); m3x3_mul( gate->transport, basis, basis ); - if( gate->type == k_gate_type_nonlocel ){ - trace_world = &world_static.worlds[ gate->target ]; + if( gate->flags & k_ent_gate_nonlocal ){ + trace_world = &world_static.instances[ gate->target ]; } } } @@ -511,7 +510,8 @@ void player__approximate_best_trajectory( player_instance *player ) float scan_radius = k_board_radius; scan_radius *= vg_clampf( t, 0.02f, 1.0f ); - int idx = spherecast_world(trace_world, co0, co1, scan_radius, &t1, n); + int idx = spherecast_world( trace_world, co0, co1, scan_radius, &t1, n, + k_material_flag_walking ); if( idx != -1 ){ v3f co; v3_lerp( co0, co1, t1, co ); @@ -598,7 +598,8 @@ void player__approximate_best_trajectory( player_instance *player ) v3f n; int idx = spherecast_world( world0, co0,co1, - k_board_radius*0.1f, &t1, n); + k_board_radius*0.1f, &t1, n, + k_material_flag_walking ); if( idx != -1 ){ goto invalidated_grind; } @@ -657,9 +658,9 @@ invalidated_grind:; } if( best ){ - v3_copy( best->n, s->land_normal ); + v3_copy( best->n, s->state.land_normal ); v3_copy( best->v, player->rb.v ); - s->land_dist = best->land_dist; + s->state.land_dist = best->land_dist; s->state.gravity_bias = best->gravity; @@ -671,8 +672,8 @@ invalidated_grind:; joystick_state( k_srjoystick_steer, steer ); v2_normalize_clamp( steer ); - if( (fabsf(steer[1]) > 0.5f) && (s->land_dist >= 1.5f) ){ - s->state.flip_rate = (1.0f/s->land_dist) * vg_signf(steer[1]) * + if( (fabsf(steer[1]) > 0.5f) && (s->state.land_dist >= 1.5f) ){ + s->state.flip_rate = (1.0f/s->state.land_dist) * vg_signf(steer[1]) * s->state.reverse ; s->state.flip_time = 0.0f; v3_copy( player->rb.to_world[0], s->state.flip_axis ); @@ -683,7 +684,7 @@ invalidated_grind:; } } else{ - v3_copy( player->basis[1], s->land_normal ); + v3_copy( player->basis[1], s->state.land_normal ); } } @@ -703,10 +704,10 @@ VG_STATIC void skate_apply_air_model( player_instance *player ) if( s->state.activity_prev > k_skate_activity_air_to_grind ) player__approximate_best_trajectory( player ); - float angle = v3_dot( player->rb.to_world[1], s->land_normal ); + float angle = v3_dot( player->rb.to_world[1], s->state.land_normal ); angle = vg_clampf( angle, -1.0f, 1.0f ); v3f axis; - v3_cross( player->rb.to_world[1], s->land_normal, axis ); + v3_cross( player->rb.to_world[1], s->state.land_normal, axis ); v4f correction; q_axis_angle( correction, axis, @@ -722,15 +723,15 @@ VG_STATIC void skate_apply_trick_model( player_instance *player ) v3f Fd, Fs, F; v3f strength = { 3.7f, 3.6f, 8.0f }; - v3_muls( s->state.board_trick_residualv, -4.0f , Fd ); - v3_muls( s->state.board_trick_residuald, -10.0f, Fs ); + v3_muls( s->state.trick_residualv, -4.0f , Fd ); + v3_muls( s->state.trick_residuald, -10.0f, Fs ); v3_add( Fd, Fs, F ); v3_mul( strength, F, F ); - v3_muladds( s->state.board_trick_residualv, F, k_rb_delta, - s->state.board_trick_residualv ); - v3_muladds( s->state.board_trick_residuald, s->state.board_trick_residualv, - k_rb_delta, s->state.board_trick_residuald ); + v3_muladds( s->state.trick_residualv, F, k_rb_delta, + s->state.trick_residualv ); + v3_muladds( s->state.trick_residuald, s->state.trick_residualv, + k_rb_delta, s->state.trick_residuald ); if( s->state.activity <= k_skate_activity_air_to_grind ){ if( v3_length2( s->state.trick_vel ) < 0.0001f ) @@ -763,7 +764,7 @@ VG_STATIC void skate_apply_trick_model( player_instance *player ) s->state.trick_euler[0] = roundf( s->state.trick_euler[0] ); s->state.trick_euler[1] = roundf( s->state.trick_euler[1] ); s->state.trick_euler[2] = roundf( s->state.trick_euler[2] ); - v3_copy( s->state.trick_vel, s->state.board_trick_residualv ); + v3_copy( s->state.trick_vel, s->state.trick_residualv ); v3_zero( s->state.trick_vel ); } @@ -1096,69 +1097,55 @@ VG_STATIC void skate_integrate( player_instance *player ) rb_update_transform( &player->rb ); } -/* - * 1 2 or 3 - */ - -VG_STATIC void skate_copy_holdout( player_instance *player ) -{ - struct player_skate *s = &player->_skate; - struct player_avatar *av = player->playeravatar; - struct skeleton *sk = &av->sk; - skeleton_copy_pose( sk, s->holdout, player->holdout_pose ); -} - -VG_STATIC enum trick_type player_skate_trick_input( player_instance *player ) -{ +VG_STATIC enum trick_type player_skate_trick_input( player_instance *player ){ return (button_press( k_srbind_trick0 ) ) | (button_press( k_srbind_trick1 ) << 1) | (button_press( k_srbind_trick2 ) << 1) | (button_press( k_srbind_trick2 ) ); } -VG_STATIC void player__skate_pre_update( player_instance *player ) -{ +VG_STATIC void player__skate_pre_update( player_instance *player ){ struct player_skate *s = &player->_skate; if( button_down( k_srbind_use ) ){ player->subsystem = k_player_subsystem_walk; v3f angles; - v3_copy( player->cam.angles, angles ); - angles[2] = 0.0f; + v3_copy( player->cam.angles, player->angles ); + player->angles[2] = 0.0f; - skate_copy_holdout( player ); - player->holdout_time = 0.34f; + player__begin_holdout( player ); player__skate_kill_audio( player ); - player__walk_transition( player, angles ); + player__walk_transition( player ); return; } - enum trick_type trick = k_trick_type_none; - if( (s->state.activity <= k_skate_activity_air_to_grind) && - (trick = player_skate_trick_input( player )) ) - { - if( (vg.time - s->state.jump_time) < 0.1f ){ - v3_zero( s->state.trick_vel ); - s->state.trick_time = 0.0f; - - if( trick == k_trick_type_kickflip ){ - s->state.trick_vel[0] = 3.0f; - } - else if( trick == k_trick_type_shuvit ){ - s->state.trick_vel[2] = 3.0f; - } - else if( trick == k_trick_type_treflip ){ - s->state.trick_vel[0] = 2.0f; - s->state.trick_vel[2] = 2.0f; + if( s->state.activity <= k_skate_activity_air_to_grind ){ + enum trick_type trick = k_trick_type_none; + if( (trick = player_skate_trick_input( player )) ){ + if( (vg.time - s->state.jump_time) < 0.1f ){ + v3_zero( s->state.trick_vel ); + s->state.trick_time = 0.0f; + + if( trick == k_trick_type_kickflip ){ + s->state.trick_vel[0] = 3.0f; + } + else if( trick == k_trick_type_shuvit ){ + s->state.trick_vel[2] = 3.0f; + } + else if( trick == k_trick_type_treflip ){ + s->state.trick_vel[0] = 2.0f; + s->state.trick_vel[2] = 2.0f; + } + s->state.trick_type = trick; } - s->state.trick_type = trick; } } + else + s->state.trick_type = k_trick_type_none; } -VG_STATIC void player__skate_post_update( player_instance *player ) -{ +VG_STATIC void player__skate_post_update( player_instance *player ){ struct player_skate *s = &player->_skate; for( int i=0; ipossible_jump_count; i++ ){ @@ -1320,8 +1307,7 @@ VG_STATIC void player__skate_post_update( player_instance *player ) VG_STATIC int skate_compute_surface_alignment( player_instance *player, v3f ra, u32 colour, - v3f surface_normal, v3f axel_dir ) -{ + v3f surface_normal, v3f axel_dir ){ struct player_skate *s = &player->_skate; world_instance *world = world_current_instance(); @@ -1341,27 +1327,25 @@ int skate_compute_surface_alignment( player_instance *player, int res_l = 0, res_r = 0; - for( int i=0; i<8; i++ ) - { + for( int i=0; i<8; i++ ){ float t = 1.0f - (float)i * (1.0f/8.0f); v3_muladds( truck, player->rb.to_world[0], -k_board_radius*t, left ); v3_muladds( left, player->rb.to_world[1], k_board_radius, left ); ray_l.dist = 2.1f * k_board_radius; - res_l = ray_world( world, left, dir, &ray_l ); + res_l = ray_world( world, left, dir, &ray_l, k_material_flag_walking ); if( res_l ) break; } - for( int i=0; i<8; i++ ) - { + for( int i=0; i<8; i++ ){ float t = 1.0f - (float)i * (1.0f/8.0f); v3_muladds( truck, player->rb.to_world[0], k_board_radius*t, right ); v3_muladds( right, player->rb.to_world[1], k_board_radius, right ); ray_r.dist = 2.1f * k_board_radius; - res_r = ray_world( world, right, dir, &ray_r ); + res_r = ray_world( world, right, dir, &ray_r, k_material_flag_walking ); if( res_r ) break; @@ -1373,20 +1357,17 @@ int skate_compute_surface_alignment( player_instance *player, v3_muladds( truck, player->rb.to_world[1], -k_board_radius, midpoint ); v3_zero( tangent_average ); - if( res_l || res_r ) - { + if( res_l || res_r ){ v3f p0, p1, t; v3_copy( midpoint, p0 ); v3_copy( midpoint, p1 ); - if( res_l ) - { + if( res_l ){ v3_copy( ray_l.pos, p0 ); v3_cross( ray_l.normal, player->rb.to_world[0], t ); v3_add( t, tangent_average, tangent_average ); } - if( res_r ) - { + if( res_r ){ v3_copy( ray_r.pos, p1 ); v3_cross( ray_r.normal, player->rb.to_world[0], t ); v3_add( t, tangent_average, tangent_average ); @@ -1395,14 +1376,12 @@ int skate_compute_surface_alignment( player_instance *player, v3_sub( p1, p0, v0 ); v3_normalize( v0 ); } - else - { + else{ /* fallback: use the closes point to the trucks */ v3f closest; int idx = bh_closest_point( world->geo_bh, midpoint, closest, 0.1f ); - if( idx != -1 ) - { + if( idx != -1 ){ u32 *tri = &world->scene_geo.arrindices[ idx * 3 ]; v3f verts[3]; @@ -1443,8 +1422,7 @@ int skate_compute_surface_alignment( player_instance *player, return 1; } -VG_STATIC void skate_weight_distribute( player_instance *player ) -{ +VG_STATIC void skate_weight_distribute( player_instance *player ){ struct player_skate *s = &player->_skate; v3_zero( s->weight_distribution ); @@ -1502,8 +1480,7 @@ VG_STATIC void skate_weight_distribute( player_instance *player ) } } -VG_STATIC void skate_adjust_up_direction( player_instance *player ) -{ +VG_STATIC void skate_adjust_up_direction( player_instance *player ){ struct player_skate *s = &player->_skate; if( s->state.activity == k_skate_activity_ground ){ @@ -1526,8 +1503,7 @@ VG_STATIC void skate_adjust_up_direction( player_instance *player ) } } -VG_STATIC int skate_point_visible( v3f origin, v3f target ) -{ +VG_STATIC int skate_point_visible( v3f origin, v3f target ){ v3f dir; v3_sub( target, origin, dir ); @@ -1536,22 +1512,21 @@ VG_STATIC int skate_point_visible( v3f origin, v3f target ) v3_muls( dir, 1.0f/ray.dist, dir ); ray.dist -= 0.025f; - if( ray_world( world_current_instance(), origin, dir, &ray ) ) + if( ray_world( world_current_instance(), origin, dir, &ray, + k_material_flag_walking ) ) return 0; return 1; } -VG_STATIC void skate_grind_orient( struct grind_info *inf, m3x3f mtx ) -{ +VG_STATIC void skate_grind_orient( struct grind_info *inf, m3x3f mtx ){ v3_copy( inf->dir, mtx[0] ); v3_copy( inf->n, mtx[1] ); v3_cross( mtx[0], mtx[1], mtx[2] ); } VG_STATIC void skate_grind_friction( player_instance *player, - struct grind_info *inf, float strength ) -{ + struct grind_info *inf, float strength ){ v3f v2; v3_muladds( player->rb.to_world[2], inf->n, -v3_dot( player->rb.to_world[2], inf->n ), v2 ); @@ -1564,8 +1539,7 @@ VG_STATIC void skate_grind_friction( player_instance *player, } VG_STATIC void skate_grind_decay( player_instance *player, - struct grind_info *inf, float strength ) -{ + struct grind_info *inf, float strength ){ m3x3f mtx, mtx_inv; skate_grind_orient( inf, mtx ); m3x3_transpose( mtx, mtx_inv ); @@ -1580,8 +1554,7 @@ VG_STATIC void skate_grind_decay( player_instance *player, VG_STATIC void skate_grind_truck_apply( player_instance *player, float sign, struct grind_info *inf, - float strength ) -{ + float strength ){ struct player_skate *s = &player->_skate; /* REFACTOR */ @@ -2311,7 +2284,8 @@ begin_collision:; v3f n; float cast_radius = wheels[i].radius - k_penetration_slop * 2.0f; - if( spherecast_world( world, current, future, cast_radius, &t, n ) != -1) + if( spherecast_world( world, current, future, cast_radius, &t, n, + k_material_flag_walking ) != -1) max_time = vg_minf( max_time, t * s->substep ); } @@ -2358,7 +2332,8 @@ begin_collision:; float t; v3f n; if( (v3_dist2( head_wp0, head_wp1 ) > 0.001f) && - (spherecast_world( world, head_wp0, head_wp1, 0.2f, &t, n ) != -1) ) + (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 ); @@ -2405,7 +2380,7 @@ begin_collision:; rb_ct *cman = &manifold[manifold_len]; int l = rb_capsule__scene( mtx, &capsule, NULL, &world->rb_geo.inf.scene, - cman ); + cman, k_material_flag_walking ); /* weld joints */ for( int i=0; istate.trick_euler[2] ); } -VG_STATIC void player__skate_animate( player_instance *player, - player_animation *dest ) -{ +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_avatar *av = player->playeravatar; - struct skeleton *sk = &av->sk; + struct player_skate_animator *animator = &s->animator; /* Head */ float kheight = 2.0f, kleg = 0.6f; - v3f offset; - v3_zero( offset ); + v3_zero( animator->offset ); v3f cog_local, cog_ideal; m4x3_mulv( player->rb.to_local, s->state.cog, cog_local ); @@ -2691,33 +2662,35 @@ VG_STATIC void player__skate_animate( player_instance *player, v3_normalize( cog_ideal ); m3x3_mulv( player->rb.to_local, cog_ideal, cog_ideal ); - v3_sub( cog_ideal, cog_local, offset ); + v3_sub( cog_ideal, cog_local, animator->offset ); - - v3_muls( offset, 4.0f, offset ); - offset[1] *= -1.0f; + 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 ); - state->wobble[0] = vg_lerpf( state->wobble[0], kicks*kicks*sign, - 6.0f*vg.time_delta); - state->wobble[1] = vg_lerpf( state->wobble[1], state->wobble[0], - 2.4f*vg.time_delta); + 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; - offset[0] *= 0.26f; - offset[0] += state->wobble[1]*3.0f; + animator->offset[1] *= -0.3f; + animator->offset[2] *= 0.01f; - offset[1] *= -0.3f; - 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); - offset[0]=vg_clampf(offset[0],-0.8f,0.8f) - *(1.0f-fabsf(state->blend_slide)*0.9f); - offset[1]=vg_clampf(offset[1],-0.5f,0.0f); + v3_muls( animator->offset, 0.3f, player->cam_control.tpv_offset_extra ); - v3_muls( 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 @@ -2730,387 +2703,405 @@ VG_STATIC void player__skate_animate( player_instance *player, if( s->state.activity == k_skate_activity_ground ) desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f ); - state->blend_slide = - vg_lerpf( state->blend_slide, desired, 2.4f*vg.time_delta); + 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; + 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; + 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; + if( s->state.activity >= k_skate_activity_grind_any ) + wdist = 0.0f; - state->blend_z = - vg_lerpf( state->blend_z, dirz, 2.4f*vg.time_delta ); - state->blend_x = - vg_lerpf( state->blend_x, dirx, 0.6f*vg.time_delta ); - state->blend_fly = - vg_lerpf( state->blend_fly, fly, 3.4f*vg.time_delta ); - state->blend_weight = - vg_lerpf( state->blend_weight, wdist, 9.0f*vg.time_delta ); - } + 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 ); - 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( curspeed * 0.03f, 0.0f, 1.0f ); - state->blend_stand = - vg_lerpf( state->blend_stand, stand, 6.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; - /* stand/crouch */ - float dir_frame = state->blend_z * (15.0f/30.0f), - stand_blend = offset[1]*-2.0f; + 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; + } - v2f steer; - joystick_state( k_srjoystick_steer, steer ); - f32 lean1, - lean2 = steer[0] * s->state.reverse * -0.36f, - lean; + /* 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( 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; + 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; } - lean1 = state->blend_slide * s->state.delayed_slip_dir; + } - if( fabsf(lean1)>fabsf(lean2) ) lean = lean1; - else lean = lean2; + 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 ); - if( ((int)roundf(s->state.trick_euler[0])) % 2 ) lean = -lean; - lean = vg_clampf( lean, -1.0f, 1.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 ); - player->board_pose.lean = vg_lerpf( player->board_pose.lean, lean, - vg.time_delta * 18.0f ); + /* grab */ + v2f grab_input; + joystick_state( k_srjoystick_grab, grab_input ); + v2_add( s->state.grab_mouse_delta, grab_input, grab_input ); - v3f local_cog; - m4x3_mulv( player->rb.to_local, s->state.cog, local_cog ); - stand_blend = vg_clampf( 1.0f-local_cog[1], 0, 1 ); + 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; - 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 ); + /* steer */ + joystick_state( k_srjoystick_steer, animator->steer ); - /* sliding */ - float slide_frame = state->blend_x * (15.0f/30.0f); - skeleton_sample_anim( sk, s->anim_slide, slide_frame, bpose ); - skeleton_lerp_pose( sk, apose, bpose, state->blend_slide, apose ); - - /* pushing */ - double push_time = vg.time - s->state.start_push; - state->blend_push = vg_lerpf( state->blend_push, - (vg.time - s->state.cur_push) < 0.125, - 6.0f*vg.time_delta ); - - if( s->state.reverse > 0.0f ) - skeleton_sample_anim( sk, s->anim_push, push_time, bpose ); - else - skeleton_sample_anim( sk, s->anim_push_reverse, push_time, bpose ); + 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 ); - skeleton_lerp_pose( sk, apose, bpose, state->blend_push, apose ); + t = 1.0f - vg_minf( 1.0f, fabsf( t * 1.1f ) ); + t = sign * (1.0f-t*t); - /* trick setup */ - float jump_start_frame = 14.0f/30.0f; + 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 ){ + if( v4_length(s->state.smoothed_rotation) <= 0.1f || + v4_length(s->state.smoothed_rotation) >= 1.1f ){ + vg_warn( "FIX THIS! CARROT\n" ); /* this never happens anymore? */ + v4_copy( player->rb.q, s->state.smoothed_rotation ); + } + 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 ); - float charge = s->state.jump_charge; - state->blend_jump = - vg_lerpf( state->blend_jump, charge, 8.4f*vg.time_delta ); + v3f yaw_ref = {1.0f,0.0f,0.0f}, + yaw_smooth = {1.0f,0.0f,0.0f}; + q_mulv( player->rb.q, yaw_ref, yaw_ref ); + q_mulv( s->state.smoothed_rotation, yaw_smooth, yaw_smooth ); + m3x3_mulv( player->rb.to_local, yaw_smooth, yaw_smooth ); + m3x3_mulv( player->rb.to_local, yaw_ref, yaw_ref ); - float setup_frame = charge * jump_start_frame, - setup_blend = vg_minf( state->blend_jump, 1.0f ); - - float jump_frame = (vg.time - s->state.jump_time) + jump_start_frame; - if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) ) - setup_frame = jump_frame; + f32 yaw_counter_rotate = v3_dot(yaw_ref,yaw_smooth); + yaw_counter_rotate = vg_clampf(yaw_counter_rotate,-0.7f,0.7f); + yaw_counter_rotate = acosf( yaw_counter_rotate ); + yaw_counter_rotate *= 1.0f-animator->fly; - struct skeleton_anim *jump_anim = s->state.jump_dir? - s->anim_ollie: - s->anim_ollie_reverse; + v3f ndir; + m3x3_mulv( player->rb.to_local, s->state.up_dir, ndir ); + v3_normalize( ndir ); - skeleton_sample_anim_clamped( sk, jump_anim, setup_frame, bpose ); - skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose ); - } - - mdl_keyframe air_pose[32]; - { - v2f steer; - joystick_state( k_srjoystick_steer, steer ); + v3f up = { 0.0f, 1.0f, 0.0f }; - float target = -steer[1]; + float a = v3_dot( ndir, up ); + a = acosf( vg_clampf( a, -1.0f, 1.0f ) ); - state->blend_airdir = - vg_lerpf( state->blend_airdir, target, 2.4f*vg.time_delta ); + v3f axis; + v4f qcounteryaw, qfixup; - float air_frame = (state->blend_airdir*0.5f+0.5f) * (15.0f/30.0f); - skeleton_sample_anim( sk, s->anim_air, air_frame, apose ); - - static v2f grab_choice; + v3_cross( up, ndir, axis ); + q_axis_angle( qfixup, axis, a ); - v2f grab_input; - joystick_state( k_srjoystick_grab, grab_input ); - v2_add( s->state.grab_mouse_delta, grab_input, grab_input ); + q_axis_angle( qcounteryaw, (v3f){0.0f,1.0f,0.0f}, yaw_counter_rotate ); + q_mul( qcounteryaw, qfixup, animator->qfixuptotal ); + q_normalize( animator->qfixuptotal ); - if( v2_length2( grab_input ) <= 0.001f ) - grab_input[0] = -1.0f; - else - v2_normalize_clamp( grab_input ); - v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice ); + v3f p1, p2; + m3x3_mulv( player->rb.to_world, up, p1 ); + m3x3_mulv( player->rb.to_world, ndir, p2 ); - float ang = atan2f( grab_choice[0], grab_choice[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, s->state.grabbing, air_pose ); + vg_line_arrow( player->rb.co, p1, 0.25f, VG__PINK ); + vg_line_arrow( player->rb.co, p2, 0.25f, VG__PINK ); } + else q_identity( animator->qfixuptotal ); + 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 ); - skeleton_lerp_pose( sk, ground_pose, air_pose, - state->blend_fly, dest->pose ); + /* 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 ); - mdl_keyframe *kf_board = &dest->pose[av->id_board-1], - *kf_foot_l = &dest->pose[av->id_ik_foot_l-1], - *kf_foot_r = &dest->pose[av->id_ik_foot_r-1], - *kf_knee_l = &dest->pose[av->id_ik_knee_l-1], - *kf_knee_r = &dest->pose[av->id_ik_knee_r-1], - *kf_hip = &dest->pose[av->id_hip-1], - *kf_wheels[] = { &dest->pose[av->id_wheel_r-1], - &dest->pose[av->id_wheel_l-1] }; + 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 grind_pose[32]; + mdl_keyframe apose[32], bpose[32]; + mdl_keyframe ground_pose[32]; { - float 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; - } + /* stand/crouch */ + f32 dir_frame = animator->z * (15.0f/30.0f), + stand_blend = animator->offset[1]*-2.0f; - float grind=s->state.activity >= k_skate_activity_grind_any? 1.0f: 0.0f; - state->blend_grind = - vg_lerpf( state->blend_grind, grind, 5.0f*vg.time_delta ); - state->blend_grind_balance = - vg_lerpf( state->blend_grind_balance, - grind_frame, 5.0f*vg.time_delta ); + pose->board.lean = animator->board_lean; - grind_frame = state->blend_grind_balance * (15.0f/30.0f); + stand_blend = vg_clampf( 1.0f-animator->local_cog[1], 0, 1 ); - skeleton_sample_anim( sk, s->anim_grind, grind_frame, apose ); - skeleton_sample_anim( sk, s->anim_grind_jump, grind_frame, bpose ); - skeleton_lerp_pose( sk, apose, bpose, state->blend_jump, grind_pose ); - } - skeleton_lerp_pose( sk, dest->pose, grind_pose, - state->blend_grind, dest->pose ); + 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 ); - float add_grab_mod = 1.0f - state->blend_fly; + /* sliding */ + skeleton_sample_anim( sk, s->anim_slide, animator->x * 0.5f, bpose ); + skeleton_lerp_pose( sk, apose, bpose, animator->slide, apose ); - /* 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; ipose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod; - dest->pose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod; + 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 ); - /* angle correction */ - if( v3_length2( s->state.up_dir ) > 0.001f ){ - - if( v4_length(s->state.smoothed_rotation) <= 0.1f || - v4_length(s->state.smoothed_rotation) >= 1.1f ){ - vg_warn( "FIX THIS! CARROT\n" ); - v4_copy( player->rb.q, s->state.smoothed_rotation ); - } - 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_ref = {1.0f,0.0f,0.0f}, - yaw_smooth = {1.0f,0.0f,0.0f}; - q_mulv( player->rb.q, yaw_ref, yaw_ref ); - q_mulv( s->state.smoothed_rotation, yaw_smooth, yaw_smooth ); - m3x3_mulv( player->rb.to_local, yaw_smooth, yaw_smooth ); - m3x3_mulv( player->rb.to_local, yaw_ref, yaw_ref ); - - float yaw_counter_rotate = v3_dot(yaw_ref,yaw_smooth); - yaw_counter_rotate = vg_clampf(yaw_counter_rotate,-1.0f,1.0f); - yaw_counter_rotate = acosf( yaw_counter_rotate ); - yaw_counter_rotate *= 1.0f-state->blend_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 qfixup, qcounteryaw, qtotal; - - v3_cross( up, ndir, axis ); - q_axis_angle( qfixup, axis, a ); - - q_axis_angle( qcounteryaw, (v3f){0.0f,1.0f,0.0f}, yaw_counter_rotate ); - q_mul( qcounteryaw, qfixup, qtotal ); - q_normalize( qtotal ); - - mdl_keyframe *kf_hip = &dest->pose[av->id_hip-1]; - v3f origin; - v3_add( av->sk.bones[av->id_hip].co, kf_hip->co, origin ); - - for( int i=0; ipose[apply_to[i]-1]; - - keyframe_rotate_around( kf, origin, av->sk.bones[apply_to[i]].co, - qtotal ); - } - - 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.25f, VG__PINK ); - vg_line_arrow( player->rb.co, p2, 0.25f, VG__PINK ); + 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 ); - v4f qtotal; - v4f qtrickr, qyawr, qpitchr, qrollr; - v3f eulerr; + 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); - v3_muls( state->board_trick_residuald, VG_TAUf, eulerr ); + skeleton_sample_anim( sk, s->anim_grabs, grab_frame, bpose ); + skeleton_lerp_pose( sk, apose, bpose, animator->grabbing, air_pose ); + } - q_axis_angle( qyawr, (v3f){0.0f,1.0f,0.0f}, eulerr[0] * 0.5f ); - q_axis_angle( qpitchr, (v3f){1.0f,0.0f,0.0f}, eulerr[1] ); - q_axis_angle( qrollr, (v3f){0.0f,0.0f,1.0f}, eulerr[2] ); + skeleton_lerp_pose( sk, ground_pose, air_pose, animator->fly, + pose->keyframes ); - q_mul( qpitchr, qrollr, qtrickr ); - q_mul( qyawr, qtrickr, qtotal ); - q_normalize( qtotal ); + 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] }; - q_mul( qtotal, kf_board->q, kf_board->q ); - /* trick rotation */ - v4f qtrick, qyaw, qpitch, qroll; - v3f euler; - v3_muls( s->state.trick_euler, VG_TAUf, euler ); + mdl_keyframe grind_pose[32]; + { + f32 frame = animator->grind_balance * 0.5f; - float jump_t = vg.time-s->state.jump_time; + 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; - 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; + /* 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 }; - q_axis_angle( qyaw, (v3f){0.0f,1.0f,0.0f}, euler[0] * 0.5f ); - q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, euler[1] + extra ); - q_axis_angle( qroll, (v3f){0.0f,0.0f,1.0f}, euler[2] ); + float apply_rates[] = { 1.0f, + 0.75f, + 0.75f, + 0.75f, + 0.75f }; - q_mul( qyaw, qroll, qtrick ); - q_mul( qpitch, qtrick, qtrick ); - q_mul( kf_board->q, qtrick, kf_board->q ); - q_normalize( kf_board->q ); + for( int i=0; ikeyframes[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; + } - struct player_board *board = - addon_cache_item_if_loaded( k_addon_type_board, - player->board_view_slot ); - - if( board ){ - /* foot weight distribution */ - if( state->blend_weight > 0.0f ){ - kf_foot_l->co[2] = - vg_lerpf( kf_foot_l->co[2], - board->truck_positions[k_board_truck_back][2]+0.3f, - 0.5f*state->blend_weight ); - } - else{ - kf_foot_r->co[2] = - vg_lerpf( kf_foot_r->co[2], - board->truck_positions[k_board_truck_front][2]-0.3f, - -0.5f*state->blend_weight ); - } - } + /* angle 'correction' */ + v3f origin; + v3_add( av->sk.bones[av->id_hip].co, kf_hip->co, origin ); - float slapm = vg_maxf( 1.0f-v3_length2( s->state.trick_vel ), 0.0f ); - state->subslap = vg_lerpf( state->subslap, slapm, vg.time_delta*10.0f ); + for( int i=0; ikeyframes[apply_to[i]-1]; + keyframe_rotate_around( kf, origin, av->sk.bones[apply_to[i]].co, + animator->qfixuptotal ); + } - kf_foot_l->co[1] += s->state.slap; - kf_foot_r->co[1] += s->state.slap; - kf_knee_l->co[1] += s->state.slap; - kf_knee_r->co[1] += s->state.slap; - kf_board->co[1] += s->state.slap * state->subslap; - kf_hip->co[1] += s->state.slap * 0.25f; + /* 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 ); - f32 l = ((s->state.activity < k_skate_activity_ground) && - v3_length2(s->state.trick_vel) > 0.1f )? 1: 0; - state->blend_trick_foot = vg_lerpf( state->blend_trick_foot, l, - 8.4f*vg.time_delta ); + 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 ); - if( s->state.trick_type == k_trick_type_kickflip ){ - kf_foot_l->co[0] += state->blend_trick_foot * 0.2f; - } - else if( s->state.trick_type == k_trick_type_shuvit ){ - kf_foot_l->co[0] += state->blend_trick_foot * 0.1f; - kf_foot_r->co[0] -= state->blend_trick_foot * 0.15f; - } - else if( s->state.trick_type == k_trick_type_treflip ){ - kf_foot_l->co[0] += state->blend_trick_foot * 0.2f; - kf_foot_r->co[0] -= state->blend_trick_foot * 0.15f; - } + 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; + } + 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; + } + 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; + } - /* - * 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. - */ + /* + * 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] ); + /* 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 ); - } + 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 = &dest->pose[av->id_head-1], - *kf_elbow_l = &dest->pose[av->id_ik_elbow_l-1], - *kf_elbow_r = &dest->pose[av->id_ik_elbow_r-1], - *kf_hand_l = &dest->pose[av->id_ik_hand_l-1], - *kf_hand_r = &dest->pose[av->id_ik_hand_r-1]; + *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(state->blend_grind, - fabsf(state->blend_weight)) * 0.3f; + warble *= vg_maxf(animator->grind, fabsf(animator->weight)) * 0.3f; v4f qrot; q_axis_angle( qrot, (v3f){0.8f,0.7f,0.6f}, warble ); @@ -3131,45 +3122,6 @@ VG_STATIC void player__skate_animate( player_instance *player, q_mul( qrot, kf_head->q, kf_head->q ); q_normalize( kf_head->q ); } - - /* transform */ - rb_extrapolate( &player->rb, dest->root_co, dest->root_q ); - - v3f ext_up,ext_co; - q_mulv( dest->root_q, (v3f){0.0f,1.0f,0.0f}, ext_up ); - v3_copy( dest->root_co, ext_co ); - v3_muladds( dest->root_co, ext_up, -0.1f, dest->root_co ); - - v4f qflip; - 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); - - float angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf, - distm = s->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( qflip, s->state.flip_axis, angle ); - q_mul( qflip, dest->root_q, dest->root_q ); - q_normalize( dest->root_q ); - - v3f rotation_point, rco; - v3_muladds( ext_co, ext_up, 0.5f, rotation_point ); - v3_sub( dest->root_co, rotation_point, rco ); - - q_mulv( qflip, rco, rco ); - v3_add( rco, rotation_point, dest->root_co ); - } - - skeleton_copy_pose( sk, dest->pose, s->holdout ); } VG_STATIC void player__skate_post_animate( player_instance *player ) @@ -3189,28 +3141,12 @@ VG_STATIC void player__skate_reset_animator( player_instance *player ){ struct player_skate *s = &player->_skate; struct player_skate_state *state = &s->state; - if( s->state.activity <= k_skate_activity_air_to_grind ) - state->blend_fly = 1.0f; - else - state->blend_fly = 0.0f; - - state->blend_slide = 0.0f; - state->blend_z = 0.0f; - state->blend_x = 0.0f; - state->blend_grind = 0.0f; - state->blend_grind_balance = 0.0f; - state->blend_stand = 0.0f; - state->blend_push = 0.0f; - state->blend_jump = 0.0f; - state->blend_airdir = 0.0f; - state->blend_weight = 0.0f; - state->subslap = 0.0f; - v2_zero( state->wobble ); - - v3_zero( state->board_trick_residuald ); - v3_zero( state->board_trick_residualv ); - v3_zero( s->truckv0[0] ); - v3_zero( s->truckv0[1] ); + 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 )