1 #ifndef PLAYER_RENDER_C
2 #define PLAYER_RENDER_C
5 #include "player_render.h"
7 #include "player_model.h"
8 #include "ent_skateshop.h"
12 #include "shaders/model_character_view.h"
13 #include "shaders/model_board_view.h"
14 #include "shaders/model_entity.h"
15 #include "shaders/model_board_view.h"
16 #include "depth_compare.h"
19 #include "player_remote.h"
20 #include "player_glide.h"
22 static void player_load_animation_reference( const char *path
){
23 mdl_context
*meta
= &localplayer
.skeleton_meta
;
24 mdl_open( meta
, path
, vg_mem
.rtmemory
);
25 mdl_load_metadata_block( meta
, vg_mem
.rtmemory
);
26 mdl_load_animation_block( meta
, vg_mem
.rtmemory
);
29 struct skeleton
*sk
= &localplayer
.skeleton
;
30 skeleton_setup( sk
, vg_mem
.rtmemory
, meta
);
32 localplayer
.id_world
= skeleton_bone_id( sk
, "world" );
33 localplayer
.id_hip
= skeleton_bone_id( sk
, "hips" );
34 localplayer
.id_chest
= skeleton_bone_id( sk
, "chest" );
35 localplayer
.id_ik_hand_l
= skeleton_bone_id( sk
, "hand.IK.L" );
36 localplayer
.id_ik_hand_r
= skeleton_bone_id( sk
, "hand.IK.R" );
37 localplayer
.id_ik_elbow_l
= skeleton_bone_id( sk
, "elbow.L" );
38 localplayer
.id_ik_elbow_r
= skeleton_bone_id( sk
, "elbow.R" );
39 localplayer
.id_head
= skeleton_bone_id( sk
, "head" );
40 localplayer
.id_foot_l
= skeleton_bone_id( sk
, "foot.L" );
41 localplayer
.id_foot_r
= skeleton_bone_id( sk
, "foot.R" );
42 localplayer
.id_ik_foot_l
= skeleton_bone_id( sk
, "foot.IK.L" );
43 localplayer
.id_ik_foot_r
= skeleton_bone_id( sk
, "foot.IK.R" );
44 localplayer
.id_board
= skeleton_bone_id( sk
, "board" );
45 localplayer
.id_wheel_l
= skeleton_bone_id( sk
, "wheel.L" );
46 localplayer
.id_wheel_r
= skeleton_bone_id( sk
, "wheel.R" );
47 localplayer
.id_ik_knee_l
= skeleton_bone_id( sk
, "knee.L" );
48 localplayer
.id_ik_knee_r
= skeleton_bone_id( sk
, "knee.R" );
49 localplayer
.id_eyes
= skeleton_bone_id( sk
, "eyes" );
51 for( i32 i
=0; i
<sk
->bone_count
; i
++ ){
52 localplayer
.skeleton_mirror
[i
] = 0;
55 for( i32 i
=1; i
<sk
->bone_count
-1; i
++ ){
56 struct skeleton_bone
*si
= &sk
->bones
[i
];
60 vg_strnull( &str
, tmp
, 64 );
61 vg_strcat( &str
, si
->name
);
63 char *L
= vg_strch( &str
, 'L' );
67 for( i32 j
=i
+1; j
<sk
->bone_count
; j
++ ){
68 struct skeleton_bone
*sj
= &sk
->bones
[j
];
70 if( !strncmp( si
->name
, sj
->name
, len
) ){
71 if( sj
->name
[len
] == 'R' ){
72 localplayer
.skeleton_mirror
[i
] = j
;
73 localplayer
.skeleton_mirror
[j
] = i
;
80 setup_ragdoll_from_skeleton( sk
, &localplayer
.ragdoll
);
82 /* allocate matrix buffers for localplayer and remote players */
83 u32 mtx_size
= sizeof(m4x3f
)*sk
->bone_count
;
84 localplayer
.final_mtx
= vg_linear_alloc( vg_mem
.rtmemory
, mtx_size
);
85 netplayers
.final_mtx
= vg_linear_alloc( vg_mem
.rtmemory
,
86 mtx_size
*NETWORK_MAX_PLAYERS
);
87 netplayers
.glider_mtx
= vg_linear_alloc( vg_mem
.rtmemory
,
88 sizeof(m4x3f
)*NETWORK_MAX_PLAYERS
);
91 /* TODO: Standard model load */
93 static void dynamic_model_load( mdl_context
*ctx
,
94 struct dynamic_model_1texture
*mdl
,
95 const char *path
, u32
*fixup_table
){
96 if( !mdl_arrcount( &ctx
->textures
) )
97 vg_fatal_error( "No texture in model" );
99 mdl_texture
*tex0
= mdl_arritm( &ctx
->textures
, 0 );
100 void *data
= vg_linear_alloc( vg_mem
.scratch
, tex0
->file
.pack_size
);
101 mdl_fread_pack_file( ctx
, &tex0
->file
, data
);
103 vg_tex2d_load_qoi_async( data
, tex0
->file
.pack_size
,
104 VG_TEX2D_NEAREST
|VG_TEX2D_CLAMP
,
107 mdl_async_load_glmesh( ctx
, &mdl
->mesh
, fixup_table
);
110 static void dynamic_model_unload( struct dynamic_model_1texture
*mdl
){
111 mesh_free( &mdl
->mesh
);
112 glDeleteTextures( 1, &mdl
->texture
);
115 /* TODO: allow error handling */
116 static void player_board_load( struct player_board
*board
,
119 vg_linear_clear( vg_mem
.scratch
);
122 mdl_open( &ctx
, path
, vg_mem
.scratch
);
123 mdl_load_metadata_block( &ctx
, vg_mem
.scratch
);
125 dynamic_model_load( &ctx
, &board
->mdl
, path
, NULL
);
127 mdl_array_ptr markers
;
128 MDL_LOAD_ARRAY( &ctx
, &markers
, ent_marker
, vg_mem
.scratch
);
130 /* TODO: you get put into a new section, the above is standard mdl loads. */
131 for( int i
=0; i
<4; i
++ )
132 board
->wheels
[i
].indice_count
= 0;
133 for( int i
=0; i
<2; i
++ )
134 board
->trucks
[i
].indice_count
= 0;
135 board
->board
.indice_count
= 0;
137 for( u32 i
=0; i
<mdl_arrcount(&ctx
.meshs
); i
++ ){
138 mdl_mesh
*mesh
= mdl_arritm( &ctx
.meshs
, i
);
140 if( mdl_entity_id_type( mesh
->entity_id
) != k_ent_marker
)
143 u32 index
= mdl_entity_id_id( mesh
->entity_id
);
144 ent_marker
*marker
= mdl_arritm( &markers
, index
);
146 mdl_submesh
*sm0
= mdl_arritm( &ctx
.submeshs
, mesh
->submesh_start
);
148 const char *alias
= mdl_pstr( &ctx
, marker
->pstr_alias
);
149 u32 lr
= marker
->transform
.co
[0] > 0.0f
? 1: 0,
150 fb
= marker
->transform
.co
[2] > 0.0f
? 0: 1;
152 if( !strcmp( alias
, "wheel" ) ){
154 board
->wheels
[ id
] = *sm0
;
155 v3_copy( marker
->transform
.co
, board
->wheel_positions
[ id
] );
157 else if( !strcmp( alias
, "board" ) ){
159 v3_copy( marker
->transform
.co
, board
->board_position
);
161 else if( !strcmp( alias
, "truck" ) ){
162 board
->trucks
[ fb
] = *sm0
;
163 v3_copy( marker
->transform
.co
, board
->truck_positions
[ fb
] );
170 static void player_board_unload( struct player_board
*board
){
171 dynamic_model_unload( &board
->mdl
);
174 static void player_model_load( struct player_model
*board
, const char *path
){
175 vg_linear_clear( vg_mem
.scratch
);
178 mdl_open( &ctx
, path
, vg_mem
.scratch
);
179 mdl_load_metadata_block( &ctx
, vg_mem
.scratch
);
181 if( !ctx
.armatures
.count
)
182 vg_fatal_error( "No armature in playermodel\n" );
184 mdl_armature
*armature
= mdl_arritm( &ctx
.armatures
, 0 );
186 u32 fixup_table
[ armature
->bone_count
+1 ];
187 for( u32 i
=0; i
<armature
->bone_count
+1; i
++ )
190 for( u32 i
=1; i
<localplayer
.skeleton
.bone_count
; i
++ ){
191 struct skeleton_bone
*sb
= &localplayer
.skeleton
.bones
[i
];
192 u32 hash
= vg_strdjb2( sb
->name
);
194 for( u32 j
=1; j
<armature
->bone_count
; j
++ ){
195 mdl_bone
*bone
= mdl_arritm( &ctx
.bones
, armature
->bone_start
+j
);
197 if( mdl_pstreq( &ctx
, bone
->pstr_name
, sb
->name
, hash
) ){
198 fixup_table
[j
+1] = i
;
204 dynamic_model_load( &ctx
, &board
->mdl
, path
, fixup_table
);
208 static void player_model_unload( struct player_model
*board
){
209 dynamic_model_unload( &board
->mdl
);
212 static void apply_full_skeleton_pose( struct skeleton
*sk
, player_pose
*pose
,
215 q_m3x3( pose
->root_q
, transform
);
216 v3_copy( pose
->root_co
, transform
[3] );
218 if( pose
->type
== k_player_pose_type_ik
){
219 skeleton_apply_pose( sk
, pose
->keyframes
,
220 k_anim_apply_defer_ik
, final_mtx
);
221 skeleton_apply_ik_pass( sk
, final_mtx
);
222 skeleton_apply_pose( sk
, pose
->keyframes
,
223 k_anim_apply_deffered_only
, final_mtx
);
224 skeleton_apply_inverses( sk
, final_mtx
);
225 skeleton_apply_transform( sk
, transform
, final_mtx
);
227 else if( pose
->type
== k_player_pose_type_fk_2
){
228 skeleton_apply_pose( sk
, pose
->keyframes
,
229 k_anim_apply_always
, final_mtx
);
230 skeleton_apply_inverses( sk
, final_mtx
);
231 skeleton_apply_transform( sk
, transform
, final_mtx
);
235 static void player__animate(void){
236 struct player_subsystem_interface
*sys
=
237 player_subsystems
[localplayer
.subsystem
];
239 struct player_board
*board
=
240 addon_cache_item_if_loaded( k_addon_type_board
,
241 localplayer
.board_view_slot
);
243 assert( sys
->animate
);
245 assert( sys
->animator_data
);
249 player_pose
*pose
= &localplayer
.pose
;
250 sys
->pose( sys
->animator_data
, pose
);
252 struct skeleton
*sk
= &localplayer
.skeleton
;
254 if( localplayer
.holdout_time
> 0.0f
){
255 skeleton_lerp_pose( sk
,
256 pose
->keyframes
,localplayer
.holdout_pose
.keyframes
,
257 localplayer
.holdout_time
, pose
->keyframes
);
259 v3_muladds( pose
->root_co
, localplayer
.holdout_pose
.root_co
,
260 localplayer
.holdout_time
, pose
->root_co
);
261 q_nlerp( pose
->root_q
, localplayer
.holdout_pose
.root_q
,
262 localplayer
.holdout_time
, pose
->root_q
);
264 localplayer
.holdout_time
-= vg
.time_frame_delta
/ 0.25f
;
267 effect_blink_apply( &localplayer
.effect_data
.blink
,
268 &localplayer
.pose
, vg
.time_delta
);
269 apply_full_skeleton_pose( sk
, &localplayer
.pose
, localplayer
.final_mtx
);
272 sys
->effects( sys
->animator_data
, localplayer
.final_mtx
, board
,
273 &localplayer
.effect_data
);
276 skeleton_debug( sk
, localplayer
.final_mtx
);
278 if( sys
->post_animate
)
281 player__observe_system( localplayer
.subsystem
);
283 sys
->sfx_comp( sys
->animator_data
);
285 player__cam_iterate();
288 static void player_copy_frame_animator( replay_frame
*frame
){
289 struct player_subsystem_interface
*sys
=
290 player_subsystems
[localplayer
.subsystem
];
292 if( sys
->animator_size
){
293 void *src
= replay_frame_data( frame
, k_replay_framedata_animator
);
294 memcpy( sys
->animator_data
, src
, sys
->animator_size
);
298 static void lerp_player_pose( player_pose
*pose0
, player_pose
*pose1
, f32 t
,
299 player_pose
*posed
){
300 struct skeleton
*sk
= &localplayer
.skeleton
;
302 v3_lerp( pose0
->root_co
, pose1
->root_co
, t
, posed
->root_co
);
303 q_nlerp( pose0
->root_q
, pose1
->root_q
, t
, posed
->root_q
);
304 posed
->type
= pose0
->type
;
305 posed
->board
.lean
= vg_lerpf( pose0
->board
.lean
, pose1
->board
.lean
, t
);
307 if( pose0
->type
!= pose1
->type
){
308 /* it would be nice to apply IK pass in-keyframes. TOO BAD! */
309 skeleton_copy_pose( sk
, pose0
->keyframes
, posed
->keyframes
);
312 skeleton_lerp_pose( sk
, pose0
->keyframes
, pose1
->keyframes
, t
,
317 static void player__observe_system( enum player_subsystem id
){
318 if( id
!= localplayer
.observing_system
){
319 struct player_subsystem_interface
*sysm1
=
320 player_subsystems
[ localplayer
.observing_system
];
322 if( sysm1
->sfx_kill
) sysm1
->sfx_kill();
323 localplayer
.observing_system
= id
;
327 static void player__animate_from_replay( replay_buffer
*replay
){
328 replay_frame
*frame
= replay
->cursor_frame
,
333 struct player_subsystem_interface
334 *sys0
= player_subsystems
[frame
->system
];
335 void *a0
= replay_frame_data( frame
, k_replay_framedata_animator
);
337 struct replay_glider_data
338 *g0
= replay_frame_data( frame
, k_replay_framedata_glider
),
344 t
= replay_subframe_time( replay
);
346 player_pose pose0
, pose1
;
348 struct player_subsystem_interface
349 *sys1
= player_subsystems
[next
->system
];
350 void *a1
= replay_frame_data( next
, k_replay_framedata_animator
);
352 sys0
->pose( a0
, &pose0
);
353 sys1
->pose( a1
, &pose1
);
355 lerp_player_pose( &pose0
, &pose1
, t
, &localplayer
.pose
);
356 g1
= replay_frame_data( next
, k_replay_framedata_glider
);
359 sys0
->pose( a0
, &localplayer
.pose
);
363 player__observe_system( frame
->system
);
365 sys0
->sfx_comp( a0
);
368 if( g0
->glider_orphan
){
370 v3_lerp( g0
->co
, g1
->co
, t
, player_glide
.rb
.co
);
371 q_nlerp( g0
->q
, g1
->q
, t
, player_glide
.rb
.q
);
374 v3_copy( g0
->co
, player_glide
.rb
.co
);
375 v4_copy( g0
->q
, player_glide
.rb
.q
);
378 rb_update_matrices( &player_glide
.rb
);
382 player_glide
.t
= vg_lerpf( g0
->t
, g1
->t
, t
);
384 player_glide
.t
= g0
->t
;
386 localplayer
.have_glider
= g0
->have_glider
;
387 localplayer
.glider_orphan
= g0
->glider_orphan
;
389 else /* no glider data in g1, or edge case we dont care about */ {
390 localplayer
.have_glider
= 0;
391 localplayer
.glider_orphan
= 0;
392 player_glide
.t
= 0.0f
;
397 apply_full_skeleton_pose( &localplayer
.skeleton
, &localplayer
.pose
,
398 localplayer
.final_mtx
);
401 static void player__pre_render(void){
402 /* shadowing/ao info */
403 struct player_board
*board
=
404 addon_cache_item_if_loaded( k_addon_type_board
,
405 localplayer
.board_view_slot
);
408 v3_copy((v3f
){0.0f
,0.1f
, board
->truck_positions
[0][2]}, vp0
);
409 v3_copy((v3f
){0.0f
,0.1f
, board
->truck_positions
[1][2]}, vp1
);
416 struct ub_world_lighting
*ubo
= &world_current_instance()->ub_lighting
;
417 v3f
*board_mtx
= localplayer
.final_mtx
[ localplayer
.id_board
];
418 m4x3_mulv( board_mtx
, vp0
, ubo
->g_board_0
);
419 m4x3_mulv( board_mtx
, vp1
, ubo
->g_board_1
);
422 static void render_board( camera
*cam
, world_instance
*world
,
423 struct player_board
*board
, m4x3f root
,
424 struct player_board_pose
*pose
,
425 enum board_shader shader
)
428 board
= &localplayer
.fallback_board
;
431 * adding depth compare to this shader
436 glActiveTexture( GL_TEXTURE0
);
437 glBindTexture( GL_TEXTURE_2D
, board
->mdl
.texture
);
439 if( shader
== k_board_shader_player
){
440 shader_model_board_view_use();
441 shader_model_board_view_uTexMain( 0 );
442 shader_model_board_view_uCamera( cam
->transform
[3] );
443 shader_model_board_view_uPv( cam
->mtx
.pv
);
445 shader_model_board_view_uDepthCompare(1);
447 shader_model_board_view_uTexSceneDepth
,
448 shader_model_board_view_uInverseRatioDepth
,
449 shader_model_board_view_uInverseRatioMain
,
452 WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world
, model_board_view
);
454 else if( shader
== k_board_shader_entity
){
455 shader_model_entity_use();
456 shader_model_entity_uTexMain( 0 );
457 shader_model_entity_uCamera( cam
->transform
[3] );
458 shader_model_entity_uPv( cam
->mtx
.pv
);
460 WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world
, model_entity
);
463 mesh_bind( &board
->mdl
.mesh
);
467 if( board
->board
.indice_count
){
469 m3x3_identity( mlocal
);
477 q_axis_angle( qroll
, (v3f
){0.0f
,0.0f
,1.0f
}, pose
->lean
* 0.6f
);
478 keyframe_rotate_around( &kf
, (v3f
){0.0f
,0.11f
,0.0f
},
479 (v3f
){0.0f
,0.0f
,0.0f
}, qroll
);
481 v3_add( board
->board_position
, kf
.co
, mlocal
[3] );
482 q_m3x3( kf
.q
, mlocal
);
484 m4x3_mul( root
, mlocal
, mlocal
);
486 if( shader
== k_board_shader_entity
){
487 /* TODO: provide a way to supply previous mdl mtx? */
488 m4x3_expand( mlocal
, m4mdl
);
489 m4x4_mul( cam
->mtx_prev
.pv
, m4mdl
, m4mdl
);
490 shader_model_entity_uPvmPrev( m4mdl
);
491 shader_model_entity_uMdl( mlocal
);
494 shader_model_board_view_uMdl( mlocal
);
496 mdl_draw_submesh( &board
->board
);
499 for( int i
=0; i
<2; i
++ ){
500 if( !board
->trucks
[i
].indice_count
)
504 m3x3_identity( mlocal
);
505 v3_copy( board
->truck_positions
[i
], mlocal
[3] );
506 m4x3_mul( root
, mlocal
, mlocal
);
508 if( shader
== k_board_shader_entity
){
509 m4x3_expand( mlocal
, m4mdl
);
510 m4x4_mul( cam
->mtx_prev
.pv
, m4mdl
, m4mdl
);
511 shader_model_entity_uPvmPrev( m4mdl
);
512 shader_model_entity_uMdl( mlocal
);
515 shader_model_board_view_uMdl( mlocal
);
517 mdl_draw_submesh( &board
->trucks
[i
] );
520 for( int i
=0; i
<4; i
++ ){
521 if( !board
->wheels
[i
].indice_count
)
525 m3x3_identity( mlocal
);
526 v3_copy( board
->wheel_positions
[i
], mlocal
[3] );
527 m4x3_mul( root
, mlocal
, mlocal
);
529 if( shader
== k_board_shader_entity
){
530 m4x3_expand( mlocal
, m4mdl
);
531 m4x4_mul( cam
->mtx_prev
.pv
, m4mdl
, m4mdl
);
532 shader_model_entity_uPvmPrev( m4mdl
);
533 shader_model_entity_uMdl( mlocal
);
536 shader_model_board_view_uMdl( mlocal
);
538 mdl_draw_submesh( &board
->wheels
[i
] );
542 static void render_playermodel( camera
*cam
, world_instance
*world
,
544 struct player_model
*model
,
545 struct skeleton
*skeleton
,
549 shader_model_character_view_use();
551 glActiveTexture( GL_TEXTURE0
);
552 glBindTexture( GL_TEXTURE_2D
, model
->mdl
.texture
);
553 shader_model_character_view_uTexMain( 0 );
554 shader_model_character_view_uCamera( cam
->transform
[3] );
555 shader_model_character_view_uPv( cam
->mtx
.pv
);
557 shader_model_character_view_uDepthCompare( depth_compare
);
560 shader_model_character_view_uTexSceneDepth
,
561 shader_model_character_view_uInverseRatioDepth
,
562 shader_model_character_view_uInverseRatioMain
,
566 WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world
, model_character_view
);
568 glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms
,
569 skeleton
->bone_count
,
571 (const GLfloat
*)final_mtx
);
573 mesh_bind( &model
->mdl
.mesh
);
574 mesh_draw( &model
->mdl
.mesh
);
577 static void player__render( camera
*cam
){
578 world_instance
*world
= world_current_instance();
579 SDL_AtomicLock( &addon_system
.sl_cache_using_resources
);
581 struct player_model
*model
=
582 addon_cache_item_if_loaded( k_addon_type_player
,
583 localplayer
.playermodel_view_slot
);
585 if( !model
) model
= &localplayer
.fallback_model
;
586 render_playermodel( cam
, world
, 1, model
, &localplayer
.skeleton
,
587 localplayer
.final_mtx
);
589 struct player_board
*board
=
590 addon_cache_item_if_loaded( k_addon_type_board
,
591 localplayer
.board_view_slot
);
593 render_board( cam
, world
, board
, localplayer
.final_mtx
[localplayer
.id_board
],
594 &localplayer
.pose
.board
, k_board_shader_player
);
596 SDL_AtomicUnlock( &addon_system
.sl_cache_using_resources
);
598 glEnable( GL_CULL_FACE
);
599 player_glide_render( cam
, world
, &localplayer
.pose
);
600 glDisable( GL_CULL_FACE
);
603 static void player_mirror_pose( mdl_keyframe pose
[32],
604 mdl_keyframe mirrored
[32] ){
605 mdl_keyframe temp
[32];
607 struct skeleton
*sk
= &localplayer
.skeleton
;
608 for( u32 i
=1; i
<sk
->bone_count
; i
++ ){
609 mdl_keyframe
*dest
= &temp
[i
-1];
610 u8 mapping
= localplayer
.skeleton_mirror
[i
];
612 if( mapping
) *dest
= pose
[mapping
-1]; /* R */
613 else *dest
= pose
[i
-1]; /* L */
615 dest
->co
[2] *= -1.0f
;
620 for( u32 i
=0; i
<sk
->bone_count
-1; i
++ ){
621 mirrored
[i
] = temp
[i
];
624 #endif /* PLAYER_RENDER_C */