4 #include "player_glide.h"
7 #include "vg/vg_rigidbody.h"
8 #include "scene_rigidbody.h"
9 #include "shaders/model_board_view.h"
10 #include "shaders/model_entity.h"
12 static f32 k_glide_steer
= 2.0f
,
15 k_glide_drag
= 0.0001f
,
16 k_glide_slip_yaw
= 0.1f
,
17 k_glide_lift_pitch
= 0.0f
,
18 k_glide_wing_orient
= -0.1f
,
19 k_glide_balance
= 1.0f
;
21 static i32 k_glide_pause
= 0;
23 static void player_glide_pre_update(void){
24 if( button_down(k_srbind_use
) ){
25 localplayer
.subsystem
= k_player_subsystem_skate
;
26 localplayer
.glider_orphan
= 1;
28 player_skate
.state
.activity
= k_skate_activity_air
;
29 player_skate
.state
.activity_prev
= k_skate_activity_air
;
31 q_mulv( localplayer
.rb
.q
, (v3f
){0.0f
,1.0f
,0.0f
}, player_skate
.state
.cog
);
32 v3_add( player_skate
.state
.cog
, localplayer
.rb
.co
,
33 player_skate
.state
.cog
);
34 v3_copy( localplayer
.rb
.v
, player_skate
.state
.cog_v
);
36 player__begin_holdout( (v3f
){0.0f
,0.0f
,0.0f
} );
37 player__skate_reset_animator();
38 player__skate_clear_mechanics();
39 v3_copy( (v3f
){0.0f
,0.0f
,0.0f
}, player_skate
.state
.trick_euler
);
41 player__approximate_best_trajectory();
45 static void massless_accel( rigidbody
*rb
, v3f delta
, v3f impulse
){
47 v3_muladds( rb
->v
, impulse
, vg
.time_fixed_delta
, rb
->v
);
49 /* Angular velocity */
51 v3_cross( delta
, impulse
, wa
);
52 v3_muladds( rb
->w
, wa
, vg
.time_fixed_delta
, rb
->w
);
55 static void calculate_lift( v3f vl
, f32 aoa_bias
,
56 v3f axis
, v3f back
, f32 power
,
59 v3_cross( back
, axis
, up
);
62 v3_muladds( vl
, axis
, -v3_dot(axis
,vl
), wind
);
64 f32 windv2
= v3_length2(wind
),
65 aoa
= atan2f( v3_dot( up
, wind
), v3_dot( back
, wind
) ) + aoa_bias
,
66 cl
= aoa
/ VG_PIf
, /* TODO: make it a curve */
67 L
= windv2
* cl
* power
;
71 v3_cross( wind
, axis
, lift_dir
);
73 /* this is where induced drag (from the flappy things) would go */
75 v3_muls( lift_dir
, L
, out_force
);
78 static void calculate_drag( v3f vl
, f32 cd
, v3f out_force
){
79 f32 v2
= v3_length2( vl
);
83 v3_muls( vl
, -cd
*v2
, out_force
);
87 * Returns true if the bottom sphere is hit
89 static bool glider_physics( v2f steer
){
90 rigidbody
*rb
= &player_glide
.rb
;
94 m3x3_mulv( rb
->to_local
, rb
->v
, vl
);
95 m3x3_mulv( rb
->to_local
, rb
->w
, wl
);
97 v3f F
, Flift
, Fslip
, Fdrag
, FslipW
, FliftW
;
99 calculate_lift( vl
, steer
[1]*k_glide_steer
,
101 (v3f
){0,sinf(k_glide_wing_orient
),cosf(k_glide_wing_orient
)},
103 v3_copy( Flift
, player_glide
.info_lift
);
104 v3_cross( (v3f
){0,0,0}, Flift
, FliftW
);
106 calculate_lift( vl
, 0.0f
,
107 (v3f
){0,1,0},(v3f
){0,0,1},
109 v3_copy( Fslip
, player_glide
.info_slip
);
110 v3_cross( (v3f
){0,k_glide_lift_pitch
,k_glide_slip_yaw
}, Fslip
, FslipW
);
112 calculate_drag( vl
, k_glide_drag
, Fdrag
);
113 v3_copy( Fdrag
, player_glide
.info_drag
);
115 v3f balance
= {0.0f
,-k_glide_balance
,0.0f
};
116 m3x3_mulv( rb
->to_local
, balance
, balance
);
119 steer
[1]*k_glide_steer
- balance
[2],
121 -steer
[0]*k_glide_steer
+ balance
[0],
124 if( player_glide
.ticker
){
125 player_glide
.ticker
--;
128 player_glide
.ticker
+= k_glide_pause
;
131 v3_add( Flift
, Fslip
, F
);
132 v3_add( F
, Fdrag
, F
);
134 m3x3_mulv( rb
->to_world
, F
, F
);
135 v3_muladds( rb
->v
, F
, vg
.time_fixed_delta
, rb
->v
);
137 v3_add( Fw
, FslipW
, Fw
);
138 v3_add( Fw
, FliftW
, Fw
);
139 m3x3_mulv( rb
->to_world
, Fw
, Fw
);
140 v3_muladds( rb
->w
, Fw
, vg
.time_fixed_delta
, rb
->w
);
144 * collisions & constraints
146 world_instance
*world
= world_current_instance();
151 rigidbody _null
= {0};
152 _null
.inv_mass
= 0.0f
;
153 m3x3_zero( _null
.iI
);
154 for( u32 i
=0; i
< vg_list_size(player_glide
.parts
); i
++ ){
156 m4x3_mul( rb
->to_world
, player_glide
.parts
[i
].mdl
, mmdl
);
158 if( player_glide
.parts
[i
].shape
== k_rb_shape_capsule
){
159 vg_line_capsule( mmdl
,
160 player_glide
.parts
[i
].inf
.r
,
161 player_glide
.parts
[i
].inf
.h
,
164 else if( player_glide
.parts
[i
].shape
== k_rb_shape_sphere
){
165 vg_line_sphere( mmdl
, player_glide
.parts
[i
].r
, 0 );
168 if( rb_global_has_space() ){
169 rb_ct
*buf
= rb_global_buffer();
173 if( player_glide
.parts
[i
].shape
== k_rb_shape_capsule
){
174 l
= rb_capsule__scene( mmdl
, &player_glide
.parts
[i
].inf
,
175 NULL
, world
->geo_bh
, buf
,
176 k_material_flag_ghosts
);
178 else if( player_glide
.parts
[i
].shape
== k_rb_shape_sphere
){
179 l
= rb_sphere__scene( mmdl
, player_glide
.parts
[i
].r
,
180 NULL
, world
->geo_bh
, buf
,
181 k_material_flag_ghosts
);
184 if( player_glide
.parts
[i
].is_damage
&& l
){
188 for( u32 j
=0; j
<l
; j
++ ){
193 rb_contact_count
+= l
;
197 rb_presolve_contacts( rb_contact_buffer
,
198 vg
.time_fixed_delta
, rb_contact_count
);
199 for( u32 i
=0; i
<10; i
++ )
200 rb_solve_contacts( rb_contact_buffer
, rb_contact_count
);
203 rb_update_matrices( rb
);
208 static void player_glide_update(void){
210 joystick_state( k_srjoystick_steer
, steer
);
212 if( glider_physics( steer
) ){
213 vg_info( "player fell off due to glider hitting ground\n" );
214 player__dead_transition( k_player_die_type_generic
);
215 localplayer
.glider_orphan
= 1;
219 static void player_glide_post_update(void){
220 v3_copy( player_glide
.rb
.co
, localplayer
.rb
.co
);
221 v4_copy( player_glide
.rb
.q
, localplayer
.rb
.q
);
222 v3_copy( player_glide
.rb
.v
, localplayer
.rb
.v
);
223 v3_copy( player_glide
.rb
.w
, localplayer
.rb
.w
);
224 rb_update_matrices( &localplayer
.rb
);
227 static void player_glide_animate(void){
228 struct player_glide
*g
= &player_glide
;
229 struct player_glide_animator
*animator
= &g
->animator
;
230 rb_extrapolate( &localplayer
.rb
, animator
->root_co
, animator
->root_q
);
233 static void player_glide_pose( void *_animator
, player_pose
*pose
){
234 struct skeleton
*sk
= &localplayer
.skeleton
;
235 struct player_glide_animator
*animator
= _animator
;
236 pose
->type
= k_player_pose_type_ik
;
237 pose
->board
.lean
= 0.0f
;
239 skeleton_sample_anim( sk
, player_glide
.anim_glide
, 0.0f
, pose
->keyframes
);
242 q_mulv( animator
->root_q
, (v3f
){0,-0.5f
,0}, temp
);
243 v3_add( animator
->root_co
, temp
, pose
->root_co
);
245 v4_copy( animator
->root_q
, pose
->root_q
);
248 static void player_glide_post_animate(void){
249 if( localplayer
.cam_control
.camera_mode
== k_cam_firstperson
)
250 localplayer
.cam_velocity_influence
= 0.0f
;
252 localplayer
.cam_velocity_influence
= 0.0f
;
255 v3_muls( localplayer
.rb
.to_world
[2], -1.0f
, fwd
);
256 v3_angles( fwd
, localplayer
.angles
);
258 localplayer
.cam_dist
= 2.0f
+ v3_length( localplayer
.rb
.v
)*0.2f
;
261 static void player_glide_animator_exchange( bitpack_ctx
*ctx
, void *data
){
262 struct player_glide_animator
*animator
= data
;
264 bitpack_qv3f( ctx
, 24, -1024.0f
, 1024.0f
, animator
->root_co
);
265 bitpack_qquat( ctx
, animator
->root_q
);
269 player_glide_remote_animator_exchange( bitpack_ctx
*ctx
, void *data
){
270 struct remote_glider_animator
*animator
= data
;
272 bitpack_qv3f( ctx
, 24, -1024.0f
, 1024.0f
, animator
->root_co
);
273 bitpack_qf32( ctx
, 8, 0.0f
, 1.0f
, &animator
->s
);
274 bitpack_qquat( ctx
, animator
->root_q
);
277 static void player_glide_im_gui(void){
278 player__debugtext( 1, "Nothing here" );
279 player__debugtext( 1, " lift: %.2f %.2f %.2f",
280 player_glide
.info_lift
[0],
281 player_glide
.info_lift
[1],
282 player_glide
.info_lift
[2] );
283 player__debugtext( 1, " slip: %.2f %.2f %.2f",
284 player_glide
.info_slip
[0],
285 player_glide
.info_slip
[1],
286 player_glide
.info_slip
[2] );
287 player__debugtext( 1, " drag: %.2f %.2f %.2f",
288 player_glide
.info_drag
[0],
289 player_glide
.info_drag
[1],
290 player_glide
.info_drag
[2] );
293 static void player_glide_equip_glider(void){
294 if( !localplayer
.have_glider
){
295 localplayer
.have_glider
= 1;
296 localplayer
.glider_orphan
= 0;
297 player_glide
.t
= -1.0f
;
301 static int ccmd_player_glider_spawn( int argc
, const char *argv
[] ){
302 if( vg_console
.cheats
){
303 player_glide_equip_glider();
306 vg_error( "Can't spawn without cheats enabled.\n" );
311 static void player_glide_bind(void)
313 u32 mask
= VG_VAR_CHEAT
|VG_VAR_PERSISTENT
;
314 VG_VAR_F32( k_glide_steer
, flags
=mask
);
315 VG_VAR_F32( k_glide_cl
, flags
=mask
);
316 VG_VAR_F32( k_glide_cs
, flags
=mask
);
317 VG_VAR_F32( k_glide_drag
, flags
=mask
);
318 VG_VAR_F32( k_glide_slip_yaw
, flags
=mask
);
319 VG_VAR_F32( k_glide_lift_pitch
, flags
=mask
);
320 VG_VAR_I32( k_glide_pause
, flags
=mask
);
321 VG_VAR_F32( k_glide_balance
, flags
=mask
);
322 VG_VAR_F32( k_glide_wing_orient
, flags
=mask
);
324 vg_console_reg_cmd( "spawn_glider", ccmd_player_glider_spawn
, NULL
);
326 f32 mass
= 0.0f
,k_density
= 8.0f
;
330 for( u32 i
=0; i
<vg_list_size(player_glide
.parts
); i
++ ){
331 /* create part transform matrix */
333 q_axis_angle( qp
, (v3f
){1,0,0}, player_glide
.parts
[i
].euler
[0] );
334 q_axis_angle( qy
, (v3f
){0,1,0}, player_glide
.parts
[i
].euler
[1] );
335 q_axis_angle( qr
, (v3f
){0,0,1}, player_glide
.parts
[i
].euler
[2] );
340 q_m3x3( q
, player_glide
.parts
[i
].mdl
);
341 v3_copy( player_glide
.parts
[i
].co
, player_glide
.parts
[i
].mdl
[3] );
343 /* add it to inertia model */
345 if( player_glide
.parts
[i
].shape
== k_rb_shape_capsule
){
346 f32 r
= player_glide
.parts
[i
].inf
.r
,
347 h
= player_glide
.parts
[i
].inf
.h
,
348 pv
= vg_capsule_volume( r
, h
),
354 vg_capsule_inertia( r
, h
, pm
, pI
);
355 vg_rotate_inertia( pI
, player_glide
.parts
[i
].mdl
);
356 vg_translate_inertia( pI
, pm
, player_glide
.parts
[i
].co
);
357 m3x3_add( I
, pI
, I
);
359 else if( player_glide
.parts
[i
].shape
== k_rb_shape_sphere
){
360 f32 r
= player_glide
.parts
[i
].r
,
361 pv
= vg_sphere_volume( r
),
366 vg_sphere_inertia( r
, pm
, pI
);
367 vg_translate_inertia( pI
, pm
, player_glide
.parts
[i
].co
);
368 m3x3_add( I
, pI
, I
);
373 m3x3_inv( I
, player_glide
.rb
.iI
);
374 player_glide
.rb
.inv_mass
= 1.0f
/ mass
;
377 struct skeleton
*sk
= &localplayer
.skeleton
;
378 player_glide
.anim_glide
= skeleton_get_anim( sk
, "glide_pose" );
380 void *alloc
= vg_mem
.rtmemory
;
381 mdl_context
*mdl
= &player_glide
.glider
;
383 mdl_open( mdl
, "models/glider.mdl", alloc
);
384 mdl_load_metadata_block( mdl
, alloc
);
386 vg_linear_clear( vg_mem
.scratch
);
388 u32 count
= mdl_arrcount( &mdl
->textures
);
389 player_glide
.glider_textures
=
390 vg_linear_alloc(alloc
,vg_align8(sizeof(GLuint
)*(count
+1)));
391 player_glide
.glider_textures
[0] = vg
.tex_missing
;
393 mdl_async_load_glmesh( mdl
, &player_glide
.glider_mesh
, NULL
);
395 for( u32 i
=0; i
<count
; i
++ ){
396 vg_linear_clear( vg_mem
.scratch
);
397 player_glide
.glider_textures
[i
+1] = vg
.tex_missing
;
399 mdl_texture
*tex
= mdl_arritm( &mdl
->textures
, i
);
400 void *data
= vg_linear_alloc( vg_mem
.scratch
, tex
->file
.pack_size
);
401 mdl_fread_pack_file( mdl
, &tex
->file
, data
);
402 vg_tex2d_load_qoi_async( data
, tex
->file
.pack_size
,
403 VG_TEX2D_LINEAR
|VG_TEX2D_CLAMP
,
404 &player_glide
.glider_textures
[i
+1] );
407 /* load trail positions */
408 mdl_array_ptr markers
;
409 MDL_LOAD_ARRAY( mdl
, &markers
, ent_marker
, vg_mem
.scratch
);
411 for( u32 i
=0; i
<mdl_arrcount( &markers
); i
++ ){
412 ent_marker
*marker
= mdl_arritm( &markers
, i
);
413 v3_copy( marker
->transform
.co
,
414 player_glide
.trail_positions
[ player_glide
.trail_count
++ ] );
416 if( player_glide
.trail_count
== vg_list_size(trails_glider
) )
422 /* allocate effects */
423 for( u32 i
=0; i
<vg_list_size(trails_glider
); i
++ ){
424 trail_alloc( &trails_glider
[i
], 200 );
428 static void player_glide_transition(void){
429 localplayer
.subsystem
= k_player_subsystem_glide
;
430 localplayer
.have_glider
= 0;
431 world_static
.challenge_target
= NULL
;
432 world_static
.challenge_timer
= 0.0f
;
433 world_static
.focused_entity
= 0;
434 world_static
.last_use
= 0.0;
435 for( u32 i
=0; i
<vg_list_size(world_static
.instances
); i
++ ){
436 world_instance
*instance
= &world_static
.instances
[i
];
437 if( instance
->status
== k_world_status_loaded
){
438 world_routes_clear( instance
);
442 v3_copy( localplayer
.rb
.co
, player_glide
.rb
.co
);
444 f32 dir
= v3_dot( localplayer
.rb
.v
, localplayer
.rb
.to_world
[2] );
448 q_axis_angle( qyaw
, (v3f
){0,1,0}, VG_TAUf
*0.5f
);
449 q_mul( qyaw
, localplayer
.rb
.q
, player_glide
.rb
.q
);
450 q_normalize( player_glide
.rb
.q
);
453 v4_copy( localplayer
.rb
.q
, player_glide
.rb
.q
);
455 v3_copy( localplayer
.rb
.v
, player_glide
.rb
.v
);
456 v3_copy( localplayer
.rb
.w
, player_glide
.rb
.w
);
457 rb_update_matrices( &player_glide
.rb
);
459 player__begin_holdout( (v3f
){0,0,0} );
462 static void render_glider_model( camera
*cam
, world_instance
*world
,
463 m4x3f mmdl
, enum board_shader shader
){
464 u32 current_tex
= 0xffffffff;
465 glActiveTexture( GL_TEXTURE0
);
467 mdl_context
*mdl
= &player_glide
.glider
;
468 mesh_bind( &player_glide
.glider_mesh
);
470 for( u32 i
=0; i
<mdl_arrcount(&mdl
->meshs
); i
++ ){
471 mdl_mesh
*mesh
= mdl_arritm( &mdl
->meshs
, i
);
474 mdl_transform_m4x3( &mesh
->transform
, mmmdl
);
475 m4x3_mul( mmdl
, mmmdl
, mmmdl
);
477 if( shader
== k_board_shader_player
)
478 shader_model_board_view_uMdl( mmmdl
);
479 else if( shader
== k_board_shader_entity
){
481 m4x3_expand( mmmdl
, m4mmmdl
);
482 m4x4_mul( cam
->mtx_prev
.pv
, m4mmmdl
, m4mmmdl
);
484 shader_model_entity_uMdl( mmmdl
);
485 shader_model_entity_uPvmPrev( m4mmmdl
);
488 for( u32 j
=0; j
<mesh
->submesh_count
; j
++ ){
489 mdl_submesh
*sm
= mdl_arritm( &mdl
->submeshs
, mesh
->submesh_start
+j
);
490 if( !sm
->material_id
) {
491 vg_error( "Invalid material ID 0\n" );
495 mdl_material
*mat
= mdl_arritm( &mdl
->materials
, sm
->material_id
-1 );
496 if( mat
->tex_diffuse
!= current_tex
){
497 glBindTexture( GL_TEXTURE_2D
,
498 player_glide
.glider_textures
[ mat
->tex_diffuse
] );
499 current_tex
= mat
->tex_diffuse
;
502 mdl_draw_submesh( sm
);
508 * TODO: more flexible way to call
509 * - this depends on the current state, but we need to pass a struct in
510 * that can hold that information instead so we can save it into
513 static void player_glide_render( camera
*cam
, world_instance
*world
,
515 if( !((localplayer
.subsystem
== k_player_subsystem_glide
) ||
516 (localplayer
.observing_system
== k_player_subsystem_glide
) ||
517 localplayer
.have_glider
||
518 localplayer
.glider_orphan
) )
521 shader_model_board_view_use();
522 shader_model_board_view_uTexMain( 0 );
523 shader_model_board_view_uCamera( cam
->transform
[3] );
524 shader_model_board_view_uPv( cam
->mtx
.pv
);
526 shader_model_board_view_uDepthCompare(1);
528 shader_model_board_view_uTexSceneDepth
,
529 shader_model_board_view_uInverseRatioDepth
,
530 shader_model_board_view_uInverseRatioMain
,
533 WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world
, model_board_view
);
536 if( localplayer
.glider_orphan
){
537 rb_extrapolate( &player_glide
.rb
, kf_res
.co
, kf_res
.q
);
538 v3_fill( kf_res
.s
, 1.0f
);
541 q_mulv( kf_res
.q
, (v3f
){0,-0.5f
,0}, temp
);
542 v3_add( temp
, kf_res
.co
, kf_res
.co
);
546 if( localplayer
.subsystem
== k_player_subsystem_glide
) target
= 1.0f
;
550 if( skaterift
.activity
!= k_skaterift_replay
)
551 vg_slewf( &player_glide
.t
, target
, vg
.time_frame_delta
* 4.0f
);
553 mdl_keyframe kf_backpack
;
555 struct skeleton
*sk
= &localplayer
.skeleton
;
556 m4x3_mulv( localplayer
.final_mtx
[localplayer
.id_chest
],
557 sk
->bones
[localplayer
.id_chest
].co
,
560 v4f qyaw
, qpitch
, qchest
, q
;
561 q_axis_angle( qyaw
, (v3f
){0,1,0}, VG_TAUf
*0.25f
);
562 q_axis_angle( qpitch
, (v3f
){1,0,0}, VG_TAUf
*0.25f
);
563 m3x3_q( localplayer
.final_mtx
[ localplayer
.id_chest
], qchest
);
565 q_mul( qyaw
, qpitch
, q
);
566 q_mul( qchest
, q
, kf_backpack
.q
);
567 q_normalize( kf_backpack
.q
);
570 if( player_glide
.t
<= 0.0f
){
571 f32 st
= player_glide
.t
+ 1.0f
,
572 sst
= vg_smoothstepf(st
),
574 scale
= vg_lerpf( 0.0f
, 0.2f
, sst
);
577 q_axis_angle( qspin
, (v3f
){0,0,1}, VG_TAUf
* isst
* 0.5f
);
578 q_mul( kf_backpack
.q
, qspin
, kf_backpack
.q
);
579 kf_backpack
.co
[1] += isst
* 1.0f
;
580 v3_muladds( kf_backpack
.co
,
581 localplayer
.final_mtx
[ localplayer
.id_chest
][0],
586 scale
= vg_lerpf( 0.2f
, 1.0f
, vg_smoothstepf(player_glide
.t
) );
590 v3_fill( kf_backpack
.s
, scale
);
592 v3_copy( pose
->root_co
, kf_res
.co
);
593 v4_copy( pose
->root_q
, kf_res
.q
);
594 v3_fill( kf_res
.s
, scale
);
596 f32 blend
= vg_smoothstepf( vg_maxf( 0, player_glide
.t
) );
597 keyframe_lerp( &kf_backpack
, &kf_res
, blend
, &kf_res
);
601 q_m3x3( kf_res
.q
, mmdl
);
602 m3x3_scale( mmdl
, kf_res
.s
);
603 v3_copy( kf_res
.co
, mmdl
[3] );
605 render_glider_model( cam
, world
, mmdl
, k_board_shader_player
);
608 v4_copy( kf_res
.q
, player_glide
.remote_animator
.root_q
);
609 v3_copy( kf_res
.co
, player_glide
.remote_animator
.root_co
);
610 player_glide
.remote_animator
.s
= kf_res
.s
[0];
613 static void player_glide_render_effects( camera
*cam
){
616 rb_extrapolate( &player_glide
.rb
, co
, q
);
617 q_mulv( q
, (v3f
){0,-0.5f
,0}, temp
);
618 v3_add( temp
, co
, co
);
620 f32 alpha
= vg_maxf( (fabsf(player_glide
.info_lift
[2])-1.0f
), 0.0f
) /18.0f
;
622 for( u32 i
=0; i
<player_glide
.trail_count
; i
++ ){
624 q_mulv( q
, player_glide
.trail_positions
[i
], vvert
);
625 v3_add( co
, vvert
, vvert
);
627 trail_system_update( &trails_glider
[i
], vg
.time_delta
, vvert
,
628 localplayer
.rb
.to_world
[1], alpha
);
630 trail_system_prerender( &trails_glider
[i
] );
631 trail_system_render( &trails_glider
[i
], &skaterift
.cam
);
635 #endif /* PLAYER_GLIDE_C */