1 #ifndef PLAYER_RENDER_C
2 #define PLAYER_RENDER_C
5 #include "player_render.h"
7 #include "player_model.h"
9 #include "shaders/model_character_view.h"
10 #include "shaders/model_board_view.h"
12 VG_STATIC
void player_avatar_load( struct player_avatar
*av
, const char *path
)
14 mdl_open( &av
->meta
, path
, vg_mem
.rtmemory
);
15 mdl_load_metadata_block( &av
->meta
, vg_mem
.rtmemory
);
16 mdl_load_animation_block( &av
->meta
, vg_mem
.rtmemory
);
17 mdl_close( &av
->meta
);
19 struct skeleton
*sk
= &av
->sk
;
20 skeleton_setup( sk
, vg_mem
.rtmemory
, &av
->meta
);
22 av
->id_hip
= skeleton_bone_id( sk
, "hips" );
23 av
->id_ik_hand_l
= skeleton_bone_id( sk
, "hand.IK.L" );
24 av
->id_ik_hand_r
= skeleton_bone_id( sk
, "hand.IK.R" );
25 av
->id_ik_elbow_l
= skeleton_bone_id( sk
, "elbow.L" );
26 av
->id_ik_elbow_r
= skeleton_bone_id( sk
, "elbow.R" );
27 av
->id_head
= skeleton_bone_id( sk
, "head" );
28 av
->id_ik_foot_l
= skeleton_bone_id( sk
, "foot.IK.L" );
29 av
->id_ik_foot_r
= skeleton_bone_id( sk
, "foot.IK.R" );
30 av
->id_board
= skeleton_bone_id( sk
, "board" );
31 av
->id_wheel_l
= skeleton_bone_id( sk
, "wheel.L" );
32 av
->id_wheel_r
= skeleton_bone_id( sk
, "wheel.R" );
33 av
->id_ik_knee_l
= skeleton_bone_id( sk
, "knee.L" );
34 av
->id_ik_knee_r
= skeleton_bone_id( sk
, "knee.R" );
37 /* TODO: Standard model load */
39 VG_STATIC
void player_model_load( struct player_model
*mdl
, const char *path
)
41 vg_linear_clear( vg_mem
.scratch
);
44 mdl_open( &ctx
, path
, vg_mem
.scratch
);
45 mdl_load_metadata_block( &ctx
, vg_mem
.scratch
);
46 mdl_load_mesh_block( &ctx
, vg_mem
.scratch
);
48 if( !mdl_arrcount( &ctx
.textures
) )
49 vg_fatal_exit_loop( "No texture in player model" );
51 mdl_texture
*tex0
= mdl_arritm( &ctx
.textures
, 0 );
52 void *data
= vg_linear_alloc( vg_mem
.scratch
, tex0
->file
.pack_size
);
53 mdl_fread_pack_file( &ctx
, &tex0
->file
, data
);
55 vg_acquire_thread_sync();
57 mdl_unpack_glmesh( &ctx
, &mdl
->mesh
);
59 /* upload first texture */
60 mdl
->texture
= vg_tex2d_new();
63 vg_tex2d_qoi( data
, tex0
->file
.pack_size
,
64 mdl_pstr( &ctx
, tex0
->file
.pstr_path
));
68 vg_release_thread_sync();
73 VG_STATIC
void player_board_load( struct player_board
*mdl
, const char *path
)
75 vg_linear_clear( vg_mem
.scratch
);
78 mdl_open( &ctx
, path
, vg_mem
.scratch
);
79 mdl_load_metadata_block( &ctx
, vg_mem
.scratch
);
80 mdl_load_mesh_block( &ctx
, vg_mem
.scratch
);
82 mdl_array_ptr markers
;
83 mdl_load_array( &ctx
, &markers
, "ent_marker", vg_mem
.scratch
);
85 if( !mdl_arrcount( &ctx
.textures
) )
86 vg_fatal_exit_loop( "No texture in board model" );
88 mdl_texture
*tex0
= mdl_arritm( &ctx
.textures
, 0 );
89 void *data
= vg_linear_alloc( vg_mem
.scratch
, tex0
->file
.pack_size
);
90 mdl_fread_pack_file( &ctx
, &tex0
->file
, data
);
92 vg_acquire_thread_sync();
94 mdl_unpack_glmesh( &ctx
, &mdl
->mesh
);
96 /* upload first texture */
97 mdl
->texture
= vg_tex2d_new();
100 vg_tex2d_qoi( data
, tex0
->file
.pack_size
,
101 mdl_pstr( &ctx
, tex0
->file
.pstr_path
));
105 vg_release_thread_sync();
109 for( int i
=0; i
<4; i
++ )
110 mdl
->wheels
[i
].indice_count
= 0;
111 for( int i
=0; i
<2; i
++ )
112 mdl
->trucks
[i
].indice_count
= 0;
113 mdl
->board
.indice_count
= 0;
115 for( u32 i
=0; i
<mdl_arrcount(&ctx
.meshs
); i
++ ){
116 mdl_mesh
*mesh
= mdl_arritm( &ctx
.meshs
, i
);
118 vg_info( "[%u]=%u:%u\n", mesh
->entity_id
,
119 mdl_entity_id_type( mesh
->entity_id
),
120 mdl_entity_id_id( mesh
->entity_id
) );
122 if( mdl_entity_id_type( mesh
->entity_id
) != k_ent_marker
)
125 u32 index
= mdl_entity_id_id( mesh
->entity_id
);
126 ent_marker
*marker
= mdl_arritm( &markers
, index
);
128 mdl_submesh
*sm0
= mdl_arritm( &ctx
.submeshs
, mesh
->submesh_start
);
130 const char *alias
= mdl_pstr( &ctx
, marker
->pstr_alias
);
131 u32 lr
= marker
->transform
.co
[0] > 0.0f
? 1: 0,
132 fb
= marker
->transform
.co
[2] > 0.0f
? 0: 1;
134 if( !strcmp( alias
, "wheel" ) ){
136 mdl
->wheels
[ id
] = *sm0
;
137 v3_copy( marker
->transform
.co
, mdl
->wheel_positions
[ id
] );
139 else if( !strcmp( alias
, "board" ) ){
141 v3_copy( marker
->transform
.co
, mdl
->board_position
);
143 else if( !strcmp( alias
, "truck" ) ){
144 mdl
->trucks
[ fb
] = *sm0
;
145 v3_copy( marker
->transform
.co
, mdl
->truck_positions
[ fb
] );
150 VG_STATIC
void player__pre_render( player_instance
*player
)
152 if( _player_animate
[ player
->subsystem
] ){
153 player_animation res
;
154 _player_animate
[ player
->subsystem
]( player
, &res
);
157 q_m3x3( res
.root_q
, transform
);
158 v3_copy( res
.root_co
, transform
[3] );
160 struct skeleton
*sk
= &player
->playeravatar
->sk
;
162 if( player
->holdout_time
> 0.0f
){
163 skeleton_lerp_pose( sk
, res
.pose
, player
->holdout_pose
,
164 player
->holdout_time
, res
.pose
);
165 player
->holdout_time
-= vg
.time_frame_delta
* 2.0f
;
168 skeleton_apply_pose( sk
, res
.pose
, k_anim_apply_defer_ik
);
169 skeleton_apply_ik_pass( sk
);
170 skeleton_apply_pose( sk
, res
.pose
, k_anim_apply_deffered_only
);
171 skeleton_apply_inverses( sk
);
172 skeleton_apply_transform( sk
, transform
);
174 skeleton_debug( sk
);
177 if( _player_post_animate
[ player
->subsystem
] )
178 _player_post_animate
[ player
->subsystem
]( player
);
180 struct player_avatar
*av
= player
->playeravatar
;
182 v3f vp0
= {0.0f
,0.1f
, player
->playerboard
->truck_positions
[0][2]},
183 vp1
= {0.0f
,0.1f
, player
->playerboard
->truck_positions
[1][2]};
185 struct ub_world_lighting
*ubo
= &get_active_world()->ub_lighting
;
186 m4x3_mulv( av
->sk
.final_mtx
[ av
->id_board
], vp0
, ubo
->g_board_0
);
187 m4x3_mulv( av
->sk
.final_mtx
[ av
->id_board
], vp1
, ubo
->g_board_1
);
189 if( player
->rewinding
){
190 if( player
->rewind_time
<= 0.0f
){
191 double taken
= vg
.time
- player
->rewind_start
;
192 vg_success( "Rewind took (rt, pt, tl): %f, %f, %f\n",
193 taken
, player
->rewind_predicted_time
,
194 player
->rewind_total_length
);
196 player
->rewinding
= 0;
197 player
->rewind_length
= 1;
198 player
->rewind_total_length
= 0.0f
;
199 player
->rewind_accum
= 0.0f
;
200 world_global
.sky_target_rate
= 1.0;
201 world_global
.time
= world_global
.last_use
;
204 world_global
.sky_target_rate
= -100.0;
206 float budget
= vg
.time_delta
,
207 overall_length
= player
->rewind_length
;
209 for( int i
=0; (i
<10)&&(player
->rewind_time
>0.0f
)&&(budget
>0.0f
); i
++ ){
210 /* Interpolate frames */
211 int i0
= floorf( player
->rewind_time
),
212 i1
= VG_MIN( i0
+1, player
->rewind_length
-1 );
214 struct rewind_frame
*fr
= &player
->rewind_buffer
[i0
],
215 *fr1
= &player
->rewind_buffer
[i1
];
217 float dist
= vg_maxf( v3_dist( fr
->pos
, fr1
->pos
), 0.001f
),
218 subl
= vg_fractf( player
->rewind_time
) + 0.001f
,
220 sramp
= 3.0f
-(1.0f
/(0.4f
+0.4f
*player
->rewind_time
)),
221 speed
= sramp
*28.0f
+ 0.5f
*player
->rewind_time
,
222 mod
= speed
* (budget
/ dist
),
224 advl
= vg_minf( mod
, subl
),
225 advt
= (advl
/ mod
) * budget
;
227 player
->dist_accum
+= speed
* advt
;
228 player
->rewind_time
-= advl
;
232 player
->rewind_time
= vg_maxf( 0.0f
, player
->rewind_time
);
234 float current_time
= vg
.time
- player
->rewind_start
,
235 remaining
= player
->rewind_predicted_time
- current_time
;
237 if( player
->rewind_sound_wait
){
238 if( player
->rewind_predicted_time
>= 6.5f
){
239 if( remaining
<= 6.5f
){
241 audio_oneshot( &audio_rewind
[3], 1.0f
, 0.0f
);
243 player
->rewind_sound_wait
= 0;
246 else if( player
->rewind_predicted_time
>= 2.5f
){
247 if( remaining
<= 2.5f
){
249 audio_oneshot( &audio_rewind
[2], 1.0f
, 0.0f
);
251 player
->rewind_sound_wait
= 0;
254 else if( player
->rewind_predicted_time
>= 1.5f
){
255 if( remaining
<= 1.5f
){
257 audio_oneshot( &audio_rewind
[1], 1.0f
, 0.0f
);
259 player
->rewind_sound_wait
= 0;
264 int i0
= floorf( player
->rewind_time
),
265 i1
= VG_MIN( i0
+1, player
->rewind_length
-1 );
267 struct rewind_frame
*fr
= &player
->rewind_buffer
[i0
],
268 *fr1
= &player
->rewind_buffer
[i1
];
270 float sub
= vg_fractf(player
->rewind_time
);
272 v3_lerp( fr
->pos
, fr1
->pos
, sub
, player
->cam_override_pos
);
273 player
->cam_override_angles
[0] =
274 vg_alerpf( fr
->ang
[0], fr1
->ang
[0], sub
);
275 player
->cam_override_angles
[1] =
276 vg_lerpf ( fr
->ang
[1], fr1
->ang
[1], sub
);
278 float blend
= player
->rewind_time
* 0.25f
;
279 player
->cam_override_strength
= vg_clampf( blend
, 0.0f
, 1.0f
);
282 else player
->cam_override_strength
= 0.0f
;
284 player__cam_iterate( player
);
287 PLAYER_API
void player__render( camera
*cam
, player_instance
*player
)
289 shader_model_character_view_use();
291 glActiveTexture( GL_TEXTURE0
);
292 glBindTexture( GL_TEXTURE_2D
, player
->playermodel
->texture
);
293 shader_model_character_view_uTexMain( 0 );
294 shader_model_character_view_uCamera( cam
->transform
[3] );
295 shader_model_character_view_uPv( cam
->mtx
.pv
);
296 shader_model_character_view_uTexSceneDepth( 1 );
297 render_fb_bind_texture( gpipeline
.fb_main
, 2, 1 );
299 render_fb_inverse_ratio( gpipeline
.fb_main
, inverse
);
300 inverse
[2] = main_camera
.farz
-main_camera
.nearz
;
302 shader_model_character_view_uInverseRatioDepth( inverse
);
303 render_fb_inverse_ratio( NULL
, inverse
);
304 inverse
[2] = cam
->farz
-cam
->nearz
;
305 shader_model_character_view_uInverseRatioMain( inverse
);
307 world_instance
*world
= get_active_world();
308 world_link_lighting_ub( world
, _shader_model_character_view
.id
);
309 world_bind_position_texture( world
, _shader_model_character_view
.id
,
310 _uniform_model_character_view_g_world_depth
, 2 );
311 world_bind_light_array( world
, _shader_model_character_view
.id
,
312 _uniform_model_character_view_uLightsArray
, 3 );
313 world_bind_light_index( world
, _shader_model_character_view
.id
,
314 _uniform_model_character_view_uLightsIndex
, 4 );
316 glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms
,
317 player
->playeravatar
->sk
.bone_count
,
319 (float *)player
->playeravatar
->sk
.final_mtx
);
321 mesh_bind( &player
->playermodel
->mesh
);
322 mesh_draw( &player
->playermodel
->mesh
);
324 /* draw skateboard */
325 shader_model_board_view_use();
326 glActiveTexture( GL_TEXTURE0
);
327 glBindTexture( GL_TEXTURE_2D
, player
->playerboard
->texture
);
328 shader_model_board_view_uTexMain( 0 );
329 shader_model_board_view_uCamera( cam
->transform
[3] );
330 shader_model_board_view_uPv( cam
->mtx
.pv
);
331 shader_model_board_view_uTexSceneDepth( 1 );
333 render_fb_inverse_ratio( gpipeline
.fb_main
, inverse
);
334 inverse
[2] = main_camera
.farz
-main_camera
.nearz
;
336 shader_model_board_view_uInverseRatioDepth( inverse
);
337 render_fb_inverse_ratio( NULL
, inverse
);
338 inverse
[2] = cam
->farz
-cam
->nearz
;
339 shader_model_board_view_uInverseRatioMain( inverse
);
341 world_link_lighting_ub( world
, _shader_model_board_view
.id
);
342 world_bind_position_texture( world
, _shader_model_board_view
.id
,
343 _uniform_model_board_view_g_world_depth
, 2 );
344 world_bind_light_array( world
, _shader_model_board_view
.id
,
345 _uniform_model_board_view_uLightsArray
, 3 );
346 world_bind_light_index( world
, _shader_model_board_view
.id
,
347 _uniform_model_board_view_uLightsIndex
, 4 );
350 m4x3_copy( player
->playeravatar
->sk
.final_mtx
[player
->playeravatar
->id_board
]
353 struct player_board
*board
= player
->playerboard
;
354 mesh_bind( &board
->mesh
);
356 if( board
->board
.indice_count
){
358 m3x3_identity( mlocal
);
359 v3_copy( board
->board_position
, mlocal
[3] );
360 m4x3_mul( root
, mlocal
, mlocal
);
362 shader_model_board_view_uMdl( mlocal
);
363 mdl_draw_submesh( &board
->board
);
366 for( int i
=0; i
<2; i
++ ){
367 if( !board
->trucks
[i
].indice_count
)
371 m3x3_identity( mlocal
);
372 v3_copy( board
->truck_positions
[i
], mlocal
[3] );
373 m4x3_mul( root
, mlocal
, mlocal
);
375 shader_model_board_view_uMdl( mlocal
);
376 mdl_draw_submesh( &board
->trucks
[i
] );
379 for( int i
=0; i
<4; i
++ ){
380 if( !board
->wheels
[i
].indice_count
)
384 m3x3_identity( mlocal
);
385 v3_copy( board
->wheel_positions
[i
], mlocal
[3] );
386 m4x3_mul( root
, mlocal
, mlocal
);
388 shader_model_board_view_uMdl( mlocal
);
389 mdl_draw_submesh( &board
->wheels
[i
] );
393 #endif /* PLAYER_RENDER_C */