-#ifndef PLAYER_GLIDE_C
-#define PLAYER_GLIDE_C
-
#include "player_glide.h"
+#include "vg/vg_rigidbody.h"
+#include "scene_rigidbody.h"
+#include "shaders/model_board_view.h"
+#include "shaders/model_entity.h"
#include "input.h"
+#include "skaterift.h"
+
+#include "player_dead.h"
+#include "player_skate.h"
+
+trail_system trails_glider[] = {
+ {
+ .width = 0.035f,
+ .lifetime = 5.0f,
+ .min_dist = 0.5f
+ },
+ {
+ .width = 0.035f,
+ .lifetime = 5.0f,
+ .min_dist = 0.5f
+ },
+};
+
+struct player_glide player_glide =
+{
+ .parts = {
+ {
+ .co = { 1.0f, 0.5f, -1.0f },
+ .euler = { VG_TAUf*0.25f, VG_TAUf*0.125f, 0.0f },
+ .shape = k_rb_shape_capsule,
+ .inf = { .h = 2.82842712475f, .r = 0.25f },
+ },
+ {
+ .co = { -1.0f, 0.5f, -1.0f },
+ .euler = { VG_TAUf*0.25f, -VG_TAUf*0.125f, 0.0f },
+ .shape = k_rb_shape_capsule,
+ .inf = { .h = 2.82842712475f, .r = 0.25f },
+ },
+ {
+ .co = { 0.0f, 0.5f, 1.0f },
+ .euler = { VG_TAUf*0.25f, VG_TAUf*0.25f, 0.0f },
+ .shape = k_rb_shape_capsule,
+ .inf = { .h = 6.0f, .r = 0.25f },
+ },
+ {
+ .co = { 0.0f, -0.5f, 0.0f },
+ .euler = { VG_TAUf*0.25f, VG_TAUf*0.25f, 0.0f },
+ .shape = k_rb_shape_capsule,
+ .inf = { .h = 2.0f, .r = 0.25f },
+ .is_damage = 1,
+ },
+ }
+};
+
+struct player_subsystem_interface player_subsystem_glide =
+{
+ .pre_update = player_glide_pre_update,
+ .update = player_glide_update,
+ .post_update = player_glide_post_update,
+ .animate = player_glide_animate,
+ .pose = player_glide_pose,
+ .post_animate = player_glide_post_animate,
+ .network_animator_exchange = player_glide_animator_exchange,
+ .im_gui = player_glide_im_gui,
+ .bind = player_glide_bind,
+
+ .animator_data = &player_glide.animator,
+ .animator_size = sizeof(player_glide.animator),
+ .name = "Glide"
+};
static f32 k_glide_steer = 2.0f,
k_glide_cl = 0.04f,
static i32 k_glide_pause = 0;
-static void player_glide_pre_update(void){
+void player_glide_pre_update(void)
+{
+ if( button_down(k_srbind_use) ){
+ localplayer.subsystem = k_player_subsystem_skate;
+ localplayer.glider_orphan = 1;
+
+ player_skate.state.activity = k_skate_activity_air;
+ player_skate.state.activity_prev = k_skate_activity_air;
+
+ q_mulv( localplayer.rb.q, (v3f){0.0f,1.0f,0.0f}, player_skate.state.cog );
+ v3_add( player_skate.state.cog, localplayer.rb.co,
+ player_skate.state.cog );
+ v3_copy( localplayer.rb.v, player_skate.state.cog_v );
+
+ player__begin_holdout( (v3f){0.0f,0.0f,0.0f} );
+ player__skate_reset_animator();
+ player__skate_clear_mechanics();
+ v3_copy( (v3f){0.0f,0.0f,0.0f}, player_skate.state.trick_euler );
+
+ player__approximate_best_trajectory();
+ }
}
static void massless_accel( rigidbody *rb, v3f delta, v3f impulse ){
/* linear */
- v3_muladds( rb->v, impulse, k_rb_delta, rb->v );
+ v3_muladds( rb->v, impulse, vg.time_fixed_delta, rb->v );
/* Angular velocity */
v3f wa;
v3_cross( delta, impulse, wa );
- v3_muladds( rb->w, wa, k_rb_delta, rb->w );
+ v3_muladds( rb->w, wa, vg.time_fixed_delta, rb->w );
}
static void calculate_lift( v3f vl, f32 aoa_bias,
f32 windv2 = v3_length2(wind),
aoa = atan2f( v3_dot( up, wind ), v3_dot( back, wind ) ) + aoa_bias,
- cl = aoa / VG_PIf, /* TODO: make it a curve */
+ cl = aoa / VG_PIf,
L = windv2 * cl * power;
v3f lift_dir;
v3_muls( vl, -cd*v2, out_force );
}
-static void player_glide_update(void){
- rigidbody *rb = &localplayer.rb;
- vg_line_sphere( rb->to_world, 1.0f, 0 );
-
- v2f steer;
- joystick_state( k_srjoystick_steer, steer );
+/*
+ * Returns true if the bottom sphere is hit
+ */
+bool glider_physics( v2f steer )
+{
+ rigidbody *rb = &player_glide.rb;
/* lift */
v3f vl, wl;
v3f balance = {0.0f,-k_glide_balance,0.0f};
m3x3_mulv( rb->to_local, balance, balance );
- vg_info( PRINTF_v3f( balance ) );
v3f Fw = {
steer[1]*k_glide_steer - balance[2],
if( player_glide.ticker ){
player_glide.ticker --;
- return;
+ return 0;
}
player_glide.ticker += k_glide_pause;
v3_add( F, Fdrag, F );
m3x3_mulv( rb->to_world, F, F );
- v3_muladds( rb->v, F, k_rb_delta, rb->v );
+ v3_muladds( rb->v, F, vg.time_fixed_delta, rb->v );
v3_add( Fw, FslipW, Fw );
v3_add( Fw, FliftW, Fw );
m3x3_mulv( rb->to_world, Fw, Fw );
- v3_muladds( rb->w, Fw, k_rb_delta, rb->w );
+ v3_muladds( rb->w, Fw, vg.time_fixed_delta, rb->w );
+
+
+ /*
+ * collisions & constraints
+ */
+ world_instance *world = world_current_instance();
+ rb_solver_reset();
+
+ bool bottom_hit = 0;
+
+ rigidbody _null = {0};
+ _null.inv_mass = 0.0f;
+ m3x3_zero( _null.iI );
+ for( u32 i=0; i < vg_list_size(player_glide.parts); i ++ ){
+ m4x3f mmdl;
+ m4x3_mul( rb->to_world, player_glide.parts[i].mdl, mmdl );
+
+ if( player_glide.parts[i].shape == k_rb_shape_capsule ){
+ vg_line_capsule( mmdl,
+ player_glide.parts[i].inf.r,
+ player_glide.parts[i].inf.h,
+ VG__BLACK );
+ }
+ else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
+ vg_line_sphere( mmdl, player_glide.parts[i].r, 0 );
+ }
+
+ if( rb_global_has_space() ){
+ rb_ct *buf = rb_global_buffer();
+
+ u32 l = 0;
+
+ if( player_glide.parts[i].shape == k_rb_shape_capsule ){
+ l = rb_capsule__scene( mmdl, &player_glide.parts[i].inf,
+ NULL, world->geo_bh, buf,
+ k_material_flag_ghosts );
+ }
+ else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
+ l = rb_sphere__scene( mmdl, player_glide.parts[i].r,
+ NULL, world->geo_bh, buf,
+ k_material_flag_ghosts );
+ }
+
+ if( player_glide.parts[i].is_damage && l ){
+ bottom_hit = 1;
+ }
+
+ for( u32 j=0; j<l; j ++ ){
+ buf[j].rba = rb;
+ buf[j].rbb = &_null;
+ }
+
+ rb_contact_count += l;
+ }
+ }
+ rb_presolve_contacts( rb_contact_buffer,
+ vg.time_fixed_delta, rb_contact_count );
+ for( u32 i=0; i<10; i ++ )
+ rb_solve_contacts( rb_contact_buffer, rb_contact_count );
+
rb_iter( rb );
- rb_update_transform( rb );
+ rb_update_matrices( rb );
+
+ return bottom_hit;
}
-static void player_glide_post_update(void){
+void player_glide_update(void)
+{
+ v2f steer;
+ joystick_state( k_srjoystick_steer, steer );
+
+ if( glider_physics( steer ) )
+ {
+ vg_info( "player fell off due to glider hitting ground\n" );
+ player__dead_transition( k_player_die_type_generic );
+ localplayer.glider_orphan = 1;
+ }
+
+ if( !world_water_player_safe( world_current_instance(), 1.0f ) )
+ return;
}
-static void player_glide_animate(void){
+void player_glide_post_update(void)
+{
+ v3_copy( player_glide.rb.co, localplayer.rb.co );
+ v4_copy( player_glide.rb.q, localplayer.rb.q );
+ v3_copy( player_glide.rb.v, localplayer.rb.v );
+ v3_copy( player_glide.rb.w, localplayer.rb.w );
+ rb_update_matrices( &localplayer.rb );
+}
+
+void player_glide_animate(void)
+{
struct player_glide *g = &player_glide;
struct player_glide_animator *animator = &g->animator;
rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
}
-static void player_glide_pose( void *_animator, player_pose *pose ){
+void player_glide_pose( void *_animator, player_pose *pose )
+{
struct skeleton *sk = &localplayer.skeleton;
struct player_glide_animator *animator = _animator;
+ pose->type = k_player_pose_type_ik;
+ pose->board.lean = 0.0f;
+
+ skeleton_sample_anim( sk, player_glide.anim_glide, 0.0f, pose->keyframes );
- skeleton_sample_anim( sk, player_glide.anim_temp, 0.0f, pose->keyframes );
+ v3f temp;
+ q_mulv( animator->root_q, (v3f){0,-0.5f,0}, temp );
+ v3_add( animator->root_co, temp, pose->root_co );
- v3_copy( animator->root_co, pose->root_co );
v4_copy( animator->root_q, pose->root_q );
}
-static void player_glide_post_animate(void){
+void player_glide_post_animate(void)
+{
if( localplayer.cam_control.camera_mode == k_cam_firstperson )
localplayer.cam_velocity_influence = 0.0f;
else
v3f fwd;
v3_muls( localplayer.rb.to_world[2], -1.0f, fwd );
v3_angles( fwd, localplayer.angles );
+
+ localplayer.cam_dist = 2.0f + v3_length( localplayer.rb.v )*0.2f;
+}
+
+void player_glide_animator_exchange( bitpack_ctx *ctx, void *data )
+{
+ struct player_glide_animator *animator = data;
+
+ bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
+ bitpack_qquat( ctx, animator->root_q );
}
-static void player_glide_im_gui(void){
- player__debugtext( 1, "Nothing here" );
- player__debugtext( 1, " lift: %.2f %.2f %.2f",
+void player_glide_remote_animator_exchange( bitpack_ctx *ctx, void *data )
+{
+ struct remote_glider_animator *animator = data;
+
+ bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
+ bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->s );
+ bitpack_qquat( ctx, animator->root_q );
+}
+
+void player_glide_im_gui( ui_context *ctx )
+{
+ player__debugtext( ctx, 1, " lift: %.2f %.2f %.2f",
player_glide.info_lift[0],
player_glide.info_lift[1],
player_glide.info_lift[2] );
- player__debugtext( 1, " slip: %.2f %.2f %.2f",
+ player__debugtext( ctx, 1, " slip: %.2f %.2f %.2f",
player_glide.info_slip[0],
player_glide.info_slip[1],
player_glide.info_slip[2] );
- player__debugtext( 1, " drag: %.2f %.2f %.2f",
+ player__debugtext( ctx, 1, " drag: %.2f %.2f %.2f",
player_glide.info_drag[0],
player_glide.info_drag[1],
player_glide.info_drag[2] );
}
-static void player_glide_bind(void){
- struct skeleton *sk = &localplayer.skeleton;
- player_glide.anim_temp = skeleton_get_anim( sk, "idle_cycle+y" );
+void player_glide_equip_glider(void)
+{
+ if( !localplayer.have_glider ){
+ localplayer.have_glider = 1;
+ localplayer.glider_orphan = 0;
+ player_glide.t = -1.0f;
+ }
+}
+
+static int ccmd_player_glider_spawn( int argc, const char *argv[] ){
+ if( vg_console.cheats ){
+ player_glide_equip_glider();
+ }
+ else {
+ vg_error( "Can't spawn without cheats enabled.\n" );
+ }
+ return 0;
+}
+void player_glide_bind(void)
+{
u32 mask = VG_VAR_CHEAT|VG_VAR_PERSISTENT;
VG_VAR_F32( k_glide_steer, flags=mask );
VG_VAR_F32( k_glide_cl, flags=mask );
VG_VAR_I32( k_glide_pause, flags=mask );
VG_VAR_F32( k_glide_balance, flags=mask );
VG_VAR_F32( k_glide_wing_orient, flags=mask );
+
+ vg_console_reg_cmd( "spawn_glider", ccmd_player_glider_spawn, NULL );
+
+ f32 mass = 0.0f,k_density = 8.0f;
+ m3x3f I;
+ m3x3_zero( I );
+
+ for( u32 i=0; i<vg_list_size(player_glide.parts); i ++ ){
+ /* create part transform matrix */
+ v4f qp, qy, qr, q;
+ q_axis_angle( qp, (v3f){1,0,0}, player_glide.parts[i].euler[0] );
+ q_axis_angle( qy, (v3f){0,1,0}, player_glide.parts[i].euler[1] );
+ q_axis_angle( qr, (v3f){0,0,1}, player_glide.parts[i].euler[2] );
+
+ q_mul( qr, qy, q );
+ q_mul( q, qp, q );
+
+ q_m3x3( q, player_glide.parts[i].mdl );
+ v3_copy( player_glide.parts[i].co, player_glide.parts[i].mdl[3] );
+
+ /* add it to inertia model */
+
+ if( player_glide.parts[i].shape == k_rb_shape_capsule ){
+ f32 r = player_glide.parts[i].inf.r,
+ h = player_glide.parts[i].inf.h,
+ pv = vg_capsule_volume( r, h ),
+ pm = pv * k_density;
+
+ mass += pm;
+
+ m3x3f pI;
+ vg_capsule_inertia( r, h, pm, pI );
+ vg_rotate_inertia( pI, player_glide.parts[i].mdl );
+ vg_translate_inertia( pI, pm, player_glide.parts[i].co );
+ m3x3_add( I, pI, I );
+ }
+ else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
+ f32 r = player_glide.parts[i].r,
+ pv = vg_sphere_volume( r ),
+ pm = pv * k_density;
+
+ mass += pm;
+ m3x3f pI;
+ vg_sphere_inertia( r, pm, pI );
+ vg_translate_inertia( pI, pm, player_glide.parts[i].co );
+ m3x3_add( I, pI, I );
+ }
+ }
+
+ /* set inverses */
+ m3x3_inv( I, player_glide.rb.iI );
+ player_glide.rb.inv_mass = 1.0f / mass;
+
+ /* resources */
+ struct skeleton *sk = &localplayer.skeleton;
+ player_glide.anim_glide = skeleton_get_anim( sk, "glide_pose" );
+
+ void *alloc = vg_mem.rtmemory;
+ mdl_context *mdl = &player_glide.glider;
+
+ mdl_open( mdl, "models/glider.mdl", alloc );
+ mdl_load_metadata_block( mdl, alloc );
+ mdl_async_full_load_std( mdl );
+
+ /* load trail positions */
+ mdl_array_ptr markers;
+ MDL_LOAD_ARRAY( mdl, &markers, ent_marker, vg_mem.scratch );
+ mdl_close( mdl );
+
+ for( u32 i=0; i<mdl_arrcount( &markers ); i ++ )
+ {
+ ent_marker *marker = mdl_arritm( &markers, i );
+ v3_copy( marker->transform.co,
+ player_glide.trail_positions[ player_glide.trail_count ++ ] );
+
+ if( player_glide.trail_count == vg_list_size(trails_glider) )
+ break;
+ }
+
+ /* allocate effects */
+ for( u32 i=0; i<vg_list_size(trails_glider); i ++ )
+ {
+ trail_alloc( &trails_glider[i], 200 );
+ }
}
-#endif /* PLAYER_GLIDE_C */
+void player_glide_transition(void)
+{
+ localplayer.subsystem = k_player_subsystem_glide;
+ localplayer.have_glider = 0;
+ world_static.challenge_target = NULL;
+ world_static.challenge_timer = 0.0f;
+ world_static.focused_entity = 0;
+ world_static.last_use = 0.0;
+ for( u32 i=0; i<vg_list_size(world_static.instances); i++ ){
+ world_instance *instance = &world_static.instances[i];
+ if( instance->status == k_world_status_loaded ){
+ world_routes_clear( instance );
+ }
+ }
+
+ v3_copy( localplayer.rb.co, player_glide.rb.co );
+
+ f32 dir = v3_dot( localplayer.rb.v, localplayer.rb.to_world[2] );
+
+ if( dir > 0.0f ){
+ v4f qyaw;
+ q_axis_angle( qyaw, (v3f){0,1,0}, VG_TAUf*0.5f );
+ q_mul( qyaw, localplayer.rb.q, player_glide.rb.q );
+ q_normalize( player_glide.rb.q );
+ }
+ else
+ v4_copy( localplayer.rb.q, player_glide.rb.q );
+
+ v3_copy( localplayer.rb.v, player_glide.rb.v );
+ v3_copy( localplayer.rb.w, player_glide.rb.w );
+ rb_update_matrices( &player_glide.rb );
+
+ player__begin_holdout( (v3f){0,0,0} );
+}
+
+void render_glider_model( vg_camera *cam, world_instance *world,
+ m4x3f mmdl, enum board_shader shader )
+{
+ u32 current_mat = 0xffffffff;
+ glActiveTexture( GL_TEXTURE0 );
+
+ mdl_context *mdl = &player_glide.glider;
+ mesh_bind( &player_glide.glider.mesh );
+
+ for( u32 i=0; i<mdl_arrcount(&mdl->meshs); i ++ )
+ {
+ mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );
+
+ m4x3f mmmdl;
+ mdl_transform_m4x3( &mesh->transform, mmmdl );
+ m4x3_mul( mmdl, mmmdl, mmmdl );
+
+ if( shader == k_board_shader_player )
+ shader_model_board_view_uMdl( mmmdl );
+ else if( shader == k_board_shader_entity )
+ {
+ m4x4f m4mmmdl;
+ m4x3_expand( mmmdl, m4mmmdl );
+ m4x4_mul( cam->mtx_prev.pv, m4mmmdl, m4mmmdl );
+
+ shader_model_entity_uMdl( mmmdl );
+ shader_model_entity_uPvmPrev( m4mmmdl );
+ }
+
+ for( u32 j=0; j<mesh->submesh_count; j ++ )
+ {
+ mdl_submesh *sm = mdl_arritm( &mdl->submeshs, mesh->submesh_start+j );
+ if( !sm->material_id )
+ {
+ vg_error( "Invalid material ID 0\n" );
+ continue;
+ }
+
+ if( sm->material_id != current_mat )
+ {
+ mdl_material *mat = mdl_arritm( &mdl->materials,sm->material_id-1 );
+ GLuint tex = vg.tex_missing;
+
+ if( mat->shader == k_shader_standard )
+ {
+ struct shader_props_standard *props = mat->props.compiled;
+
+ u32 index = props->tex_diffuse-1;
+ mdl_texture *ptex = mdl_arritm( &mdl->textures, index );
+ tex = ptex->glname;
+ }
+
+ glBindTexture( GL_TEXTURE_2D, tex );
+ current_mat = sm->material_id;
+ }
+
+ mdl_draw_submesh( sm );
+ }
+ }
+}
+
+/*
+ * TODO: more flexible way to call
+ * - this depends on the current state, but we need to pass a struct in
+ * that can hold that information instead so we can save it into
+ * the replay
+ */
+void player_glide_render( vg_camera *cam, world_instance *world,
+ player_pose *pose )
+{
+ if( !((localplayer.subsystem == k_player_subsystem_glide) ||
+ (localplayer.observing_system == k_player_subsystem_glide) ||
+ localplayer.have_glider ||
+ localplayer.glider_orphan) )
+ return;
+
+ shader_model_board_view_use();
+ shader_model_board_view_uTexMain( 0 );
+ shader_model_board_view_uCamera( cam->transform[3] );
+ shader_model_board_view_uPv( cam->mtx.pv );
+ shader_model_board_view_uDepthMode(1);
+ depth_compare_bind(
+ shader_model_board_view_uTexSceneDepth,
+ shader_model_board_view_uInverseRatioDepth,
+ shader_model_board_view_uInverseRatioMain,
+ cam );
+
+ WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world, model_board_view );
+
+ mdl_keyframe kf_res;
+ if( localplayer.glider_orphan ){
+ rb_extrapolate( &player_glide.rb, kf_res.co, kf_res.q );
+ v3_fill( kf_res.s, 1.0f );
+
+ v3f temp;
+ q_mulv( kf_res.q, (v3f){0,-0.5f,0}, temp );
+ v3_add( temp, kf_res.co, kf_res.co );
+ }
+ else {
+ f32 target;
+ if( localplayer.subsystem == k_player_subsystem_glide ) target = 1.0f;
+ else target = 0.0f;
+
+ /* TODO: TEMP */
+ if( skaterift.activity != k_skaterift_replay )
+ vg_slewf( &player_glide.t, target, vg.time_frame_delta * 4.0f );
+
+ mdl_keyframe kf_backpack;
+
+ struct skeleton *sk = &localplayer.skeleton;
+ m4x3_mulv( localplayer.final_mtx[localplayer.id_chest ],
+ sk->bones[localplayer.id_chest].co,
+ kf_backpack.co );
+
+ v4f qyaw, qpitch, qchest, q;
+ q_axis_angle( qyaw, (v3f){0,1,0}, VG_TAUf*0.25f );
+ q_axis_angle( qpitch, (v3f){1,0,0}, VG_TAUf*0.25f );
+ m3x3_q( localplayer.final_mtx[ localplayer.id_chest ], qchest );
+
+ q_mul( qyaw, qpitch, q );
+ q_mul( qchest, q, kf_backpack.q );
+ q_normalize( kf_backpack.q );
+
+ f32 scale;
+ if( player_glide.t <= 0.0f ){
+ f32 st = player_glide.t + 1.0f,
+ sst = vg_smoothstepf(st),
+ isst= 1.0f - sst;
+ scale = vg_lerpf( 0.0f, 0.2f, sst );
+
+ v4f qspin;
+ q_axis_angle( qspin, (v3f){0,0,1}, VG_TAUf * isst * 0.5f );
+ q_mul( kf_backpack.q, qspin, kf_backpack.q );
+ kf_backpack.co[1] += isst * 1.0f;
+ v3_muladds( kf_backpack.co,
+ localplayer.final_mtx[ localplayer.id_chest ][0],
+ isst * 0.25f,
+ kf_backpack.co );
+ }
+ else{
+ scale = vg_lerpf( 0.2f, 1.0f, vg_smoothstepf(player_glide.t) );
+ }
+
+
+ v3_fill( kf_backpack.s, scale );
+
+ v3_copy( pose->root_co, kf_res.co );
+ v4_copy( pose->root_q, kf_res.q );
+ v3_fill( kf_res.s, scale );
+
+ f32 blend = vg_smoothstepf( vg_maxf( 0, player_glide.t ) );
+ keyframe_lerp( &kf_backpack, &kf_res, blend, &kf_res );
+ }
+
+ m4x3f mmdl;
+ q_m3x3( kf_res.q, mmdl );
+ m3x3_scale( mmdl, kf_res.s );
+ v3_copy( kf_res.co, mmdl[3] );
+
+ render_glider_model( cam, world, mmdl, k_board_shader_player );
+
+ /* totally FUCKED */
+ v4_copy( kf_res.q, player_glide.remote_animator.root_q );
+ v3_copy( kf_res.co, player_glide.remote_animator.root_co );
+ player_glide.remote_animator.s = kf_res.s[0];
+}
+
+void player_glide_render_effects( vg_camera *cam )
+{
+ v3f co, temp;
+ v4f q;
+ rb_extrapolate( &player_glide.rb, co, q );
+ q_mulv( q, (v3f){0,-0.5f,0}, temp );
+ v3_add( temp, co, co );
+
+ f32 alpha = vg_maxf( (fabsf(player_glide.info_lift[2])-1.0f), 0.0f ) /18.0f;
+
+ for( u32 i=0; i<player_glide.trail_count; i ++ ){
+ v3f vvert;
+ q_mulv( q, player_glide.trail_positions[i], vvert );
+ v3_add( co, vvert, vvert );
+
+ trail_system_update( &trails_glider[i], vg.time_delta, vvert,
+ localplayer.rb.to_world[1], alpha );
+
+ trail_system_prerender( &trails_glider[i] );
+ trail_system_render( &trails_glider[i], &skaterift.cam );
+ }
+}