projects / carveJwlIkooP6JGAAIwe30JlM.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
clean boardshop idea
[carveJwlIkooP6JGAAIwe30JlM.git] / player_render.c
1 #ifndef PLAYER_RENDER_C
2 #define PLAYER_RENDER_C
3
4 #include "player.h"
5 #include "player_render.h"
6 #include "camera.h"
7 #include "player_model.h"
8
9 #include "shaders/model_character_view.h"
10 #include "shaders/model_board_view.h"
11 #include "shaders/model_entity.h"
12
13 VG_STATIC void player_avatar_load( struct player_avatar *av, const char *path )
14 {
15 mdl_open( &av->meta, path, vg_mem.rtmemory );
16 mdl_load_metadata_block( &av->meta, vg_mem.rtmemory );
17 mdl_load_animation_block( &av->meta, vg_mem.rtmemory );
18 mdl_close( &av->meta );
19
20 struct skeleton *sk = &av->sk;
21 skeleton_setup( sk, vg_mem.rtmemory, &av->meta );
22
23 av->id_hip = skeleton_bone_id( sk, "hips" );
24 av->id_ik_hand_l = skeleton_bone_id( sk, "hand.IK.L" );
25 av->id_ik_hand_r = skeleton_bone_id( sk, "hand.IK.R" );
26 av->id_ik_elbow_l = skeleton_bone_id( sk, "elbow.L" );
27 av->id_ik_elbow_r = skeleton_bone_id( sk, "elbow.R" );
28 av->id_head = skeleton_bone_id( sk, "head" );
29 av->id_ik_foot_l = skeleton_bone_id( sk, "foot.IK.L" );
30 av->id_ik_foot_r = skeleton_bone_id( sk, "foot.IK.R" );
31 av->id_board = skeleton_bone_id( sk, "board" );
32 av->id_wheel_l = skeleton_bone_id( sk, "wheel.L" );
33 av->id_wheel_r = skeleton_bone_id( sk, "wheel.R" );
34 av->id_ik_knee_l = skeleton_bone_id( sk, "knee.L" );
35 av->id_ik_knee_r = skeleton_bone_id( sk, "knee.R" );
36 }
37
38 /* TODO: Standard model load */
39
40 VG_STATIC void player_model_load( struct player_model *mdl, const char *path )
41 {
42 vg_linear_clear( vg_mem.scratch );
43
44 mdl_context ctx;
45 mdl_open( &ctx, path, vg_mem.scratch );
46 mdl_load_metadata_block( &ctx, vg_mem.scratch );
47
48 if( !mdl_arrcount( &ctx.textures ) )
49 vg_fatal_error( "No texture in player model" );
50
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 );
54
55 vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
56 VG_TEX2D_NEAREST|VG_TEX2D_CLAMP,
57 &mdl->texture );
58
59 mdl_async_load_glmesh( &ctx, &mdl->mesh );
60 mdl_close( &ctx );
61 }
62
63 VG_STATIC void player_board_load( struct player_board *mdl, const char *path )
64 {
65 vg_linear_clear( vg_mem.scratch );
66
67 mdl_context ctx;
68 mdl_open( &ctx, path, vg_mem.scratch );
69 mdl_load_metadata_block( &ctx, vg_mem.scratch );
70
71 mdl_array_ptr markers;
72 mdl_load_array( &ctx, &markers, "ent_marker", vg_mem.scratch );
73
74 if( !mdl_arrcount( &ctx.textures ) )
75 vg_fatal_error( "No texture in board model" );
76
77 mdl_texture *tex0 = mdl_arritm( &ctx.textures, 0 );
78 void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
79 mdl_fread_pack_file( &ctx, &tex0->file, data );
80
81 vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
82 VG_TEX2D_CLAMP|VG_TEX2D_NEAREST,
83 &mdl->texture );
84
85 mdl_async_load_glmesh( &ctx, &mdl->mesh );
86 mdl_close( &ctx );
87
88 for( int i=0; i<4; i++ )
89 mdl->wheels[i].indice_count = 0;
90 for( int i=0; i<2; i++ )
91 mdl->trucks[i].indice_count = 0;
92 mdl->board.indice_count = 0;
93
94 for( u32 i=0; i<mdl_arrcount(&ctx.meshs); i++ ){
95 mdl_mesh *mesh = mdl_arritm( &ctx.meshs, i );
96
97 if( mdl_entity_id_type( mesh->entity_id ) != k_ent_marker )
98 continue;
99
100 u32 index = mdl_entity_id_id( mesh->entity_id );
101 ent_marker *marker = mdl_arritm( &markers, index );
102
103 mdl_submesh *sm0 = mdl_arritm( &ctx.submeshs, mesh->submesh_start );
104
105 const char *alias = mdl_pstr( &ctx, marker->pstr_alias );
106 u32 lr = marker->transform.co[0] > 0.0f? 1: 0,
107 fb = marker->transform.co[2] > 0.0f? 0: 1;
108
109 if( !strcmp( alias, "wheel" ) ){
110 u32 id = fb<<1 | lr;
111 mdl->wheels[ id ] = *sm0;
112 v3_copy( marker->transform.co, mdl->wheel_positions[ id ] );
113 }
114 else if( !strcmp( alias, "board" ) ){
115 mdl->board = *sm0;
116 v3_copy( marker->transform.co, mdl->board_position );
117 }
118 else if( !strcmp( alias, "truck" ) ){
119 mdl->trucks[ fb ] = *sm0;
120 v3_copy( marker->transform.co, mdl->truck_positions[ fb ] );
121 }
122 }
123 }
124
125 VG_STATIC void player_board_unload( struct player_board *mdl )
126 {
127 mesh_free( &mdl->mesh );
128 glDeleteTextures( 1, &mdl->texture );
129 }
130
131 VG_STATIC void player__pre_render( player_instance *player )
132 {
133 if( _player_animate[ player->subsystem ] ){
134 player_animation res;
135 _player_animate[ player->subsystem ]( player, &res );
136
137 m4x3f transform;
138 q_m3x3( res.root_q, transform );
139 v3_copy( res.root_co, transform[3] );
140
141 struct skeleton *sk = &player->playeravatar->sk;
142
143 if( player->holdout_time > 0.0f ){
144 skeleton_lerp_pose( sk, res.pose, player->holdout_pose,
145 player->holdout_time, res.pose );
146 player->holdout_time -= vg.time_frame_delta * 2.0f;
147 }
148
149 skeleton_apply_pose( sk, res.pose, k_anim_apply_defer_ik );
150 skeleton_apply_ik_pass( sk );
151 skeleton_apply_pose( sk, res.pose, k_anim_apply_deffered_only );
152 skeleton_apply_inverses( sk );
153 skeleton_apply_transform( sk, transform );
154
155 skeleton_debug( sk );
156 }
157
158 if( _player_post_animate[ player->subsystem ] )
159 _player_post_animate[ player->subsystem ]( player );
160
161 struct player_avatar *av = player->playeravatar;
162
163 struct player_board *board = player->board;
164
165 v3f vp0, vp1;
166
167 if( board ){
168 v3_copy((v3f){0.0f,0.1f, board->truck_positions[0][2]}, vp0 );
169 v3_copy((v3f){0.0f,0.1f, board->truck_positions[1][2]}, vp1 );
170 }
171 else{
172 v3_zero( vp0 );
173 v3_zero( vp1 );
174 }
175
176 struct ub_world_lighting *ubo = &get_active_world()->ub_lighting;
177 m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp0, ubo->g_board_0 );
178 m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp1, ubo->g_board_1 );
179
180 if( player->immobile ){
181 player__cam_iterate( player );
182 return;
183 }
184
185 if( player->rewinding ){
186 if( player->rewind_time <= 0.0f ){
187 double taken = vg.time - player->rewind_start;
188 vg_success( "Rewind took (rt, pt, tl): %f, %f, %f\n",
189 taken, player->rewind_predicted_time,
190 player->rewind_total_length );
191
192 player->rewinding = 0;
193 player->rewind_length = 1;
194 player->rewind_total_length = 0.0f;
195 player->rewind_accum = 0.0f;
196 world_global.sky_target_rate = 1.0;
197 world_global.time = world_global.last_use;
198 }
199 else{
200 world_global.sky_target_rate = -100.0;
201
202 float budget = vg.time_delta,
203 overall_length = player->rewind_length;
204
205 for( int i=0; (i<10)&&(player->rewind_time>0.0f)&&(budget>0.0f); i++ ){
206 /* Interpolate frames */
207 int i0 = floorf( player->rewind_time ),
208 i1 = VG_MIN( i0+1, player->rewind_length-1 );
209
210 struct rewind_frame *fr = &player->rewind_buffer[i0],
211 *fr1 = &player->rewind_buffer[i1];
212
213 float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
214 subl = vg_fractf( player->rewind_time ) + 0.001f,
215
216 sramp = 3.0f-(1.0f/(0.4f+0.4f*player->rewind_time)),
217 speed = sramp*28.0f + 0.5f*player->rewind_time,
218 mod = speed * (budget / dist),
219
220 advl = vg_minf( mod, subl ),
221 advt = (advl / mod) * budget;
222
223 player->dist_accum += speed * advt;
224 player->rewind_time -= advl;
225 budget -= advt;
226 }
227
228 player->rewind_time = vg_maxf( 0.0f, player->rewind_time );
229
230 float current_time = vg.time - player->rewind_start,
231 remaining = player->rewind_predicted_time - current_time;
232
233 if( player->rewind_sound_wait ){
234 if( player->rewind_predicted_time >= 6.5f ){
235 if( remaining <= 6.5f ){
236 audio_lock();
237 audio_oneshot( &audio_rewind[3], 1.0f, 0.0f );
238 audio_unlock();
239 player->rewind_sound_wait = 0;
240 }
241 }
242 else if( player->rewind_predicted_time >= 2.5f ){
243 if( remaining <= 2.5f ){
244 audio_lock();
245 audio_oneshot( &audio_rewind[2], 1.0f, 0.0f );
246 audio_unlock();
247 player->rewind_sound_wait = 0;
248 }
249 }
250 else if( player->rewind_predicted_time >= 1.5f ){
251 if( remaining <= 1.5f ){
252 audio_lock();
253 audio_oneshot( &audio_rewind[1], 1.0f, 0.0f );
254 audio_unlock();
255 player->rewind_sound_wait = 0;
256 }
257 }
258 }
259
260 int i0 = floorf( player->rewind_time ),
261 i1 = VG_MIN( i0+1, player->rewind_length-1 );
262
263 struct rewind_frame *fr = &player->rewind_buffer[i0],
264 *fr1 = &player->rewind_buffer[i1];
265
266 float sub = vg_fractf(player->rewind_time);
267
268 v3_lerp( fr->pos, fr1->pos, sub, player->cam_override_pos );
269 player->cam_override_angles[0] =
270 vg_alerpf( fr->ang[0], fr1->ang[0], sub );
271 player->cam_override_angles[1] =
272 vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
273 player->cam_override_fov = player->cam.fov;
274
275 float blend = player->rewind_time * 0.25f;
276 player->cam_override_strength = vg_clampf( blend, 0.0f, 1.0f );
277 }
278 }
279 else player->cam_override_strength = 0.0f;
280
281 player__cam_iterate( player );
282 }
283
284 enum board_shader{
285 k_board_shader_player,
286 k_board_shader_entity
287 };
288
289 VG_STATIC void render_board( camera *cam, world_instance *world,
290 struct player_board *board, m4x3f root,
291 enum board_shader shader )
292 {
293 if( !board ) return;
294
295 v3f inverse;
296
297 glActiveTexture( GL_TEXTURE0 );
298 glBindTexture( GL_TEXTURE_2D, board->texture );
299
300 if( shader == k_board_shader_player ){
301 shader_model_board_view_use();
302 shader_model_board_view_uTexMain( 0 );
303 shader_model_board_view_uCamera( cam->transform[3] );
304 shader_model_board_view_uPv( cam->mtx.pv );
305 shader_model_board_view_uTexSceneDepth( 1 );
306
307 render_fb_inverse_ratio( gpipeline.fb_main, inverse );
308 inverse[2] = main_camera.farz-main_camera.nearz;
309
310 shader_model_board_view_uInverseRatioDepth( inverse );
311 render_fb_inverse_ratio( NULL, inverse );
312 inverse[2] = cam->farz-cam->nearz;
313 shader_model_board_view_uInverseRatioMain( inverse );
314
315 world_link_lighting_ub( world, _shader_model_board_view.id );
316 world_bind_position_texture( world, _shader_model_board_view.id,
317 _uniform_model_board_view_g_world_depth, 2 );
318 world_bind_light_array( world, _shader_model_board_view.id,
319 _uniform_model_board_view_uLightsArray, 3 );
320 world_bind_light_index( world, _shader_model_board_view.id,
321 _uniform_model_board_view_uLightsIndex, 4 );
322 }
323 else if( shader == k_board_shader_entity ){
324 shader_model_entity_use();
325 shader_model_entity_uTexMain( 0 );
326 shader_model_entity_uCamera( cam->transform[3] );
327 shader_model_entity_uPv( cam->mtx.pv );
328
329 world_link_lighting_ub( world, _shader_model_entity.id );
330 world_bind_position_texture( world, _shader_model_entity.id,
331 _uniform_model_entity_g_world_depth, 2 );
332 world_bind_light_array( world, _shader_model_entity.id,
333 _uniform_model_entity_uLightsArray, 3 );
334 world_bind_light_index( world, _shader_model_entity.id,
335 _uniform_model_entity_uLightsIndex, 4 );
336 }
337
338 mesh_bind( &board->mesh );
339
340 m4x4f m4mdl;
341
342 if( board->board.indice_count ){
343 m4x3f mlocal;
344 m3x3_identity( mlocal );
345 v3_copy( board->board_position, mlocal[3] );
346 m4x3_mul( root, mlocal, mlocal );
347
348 if( shader == k_board_shader_entity ){
349 /* TODO: provide a way to supply previous mdl mtx? */
350 m4x3_expand( mlocal, m4mdl );
351 m4x4_mul( cam->mtx_prev.pv, m4mdl, m4mdl );
352 shader_model_entity_uPvmPrev( m4mdl );
353 shader_model_entity_uMdl( mlocal );
354 }
355 else
356 shader_model_board_view_uMdl( mlocal );
357
358 mdl_draw_submesh( &board->board );
359 }
360
361 for( int i=0; i<2; i++ ){
362 if( !board->trucks[i].indice_count )
363 continue;
364
365 m4x3f mlocal;
366 m3x3_identity( mlocal );
367 v3_copy( board->truck_positions[i], mlocal[3] );
368 m4x3_mul( root, mlocal, mlocal );
369
370 if( shader == k_board_shader_entity ){
371 m4x3_expand( mlocal, m4mdl );
372 m4x4_mul( cam->mtx_prev.pv, m4mdl, m4mdl );
373 shader_model_entity_uPvmPrev( m4mdl );
374 shader_model_entity_uMdl( mlocal );
375 }
376 else
377 shader_model_board_view_uMdl( mlocal );
378
379 mdl_draw_submesh( &board->trucks[i] );
380 }
381
382 for( int i=0; i<4; i++ ){
383 if( !board->wheels[i].indice_count )
384 continue;
385
386 m4x3f mlocal;
387 m3x3_identity( mlocal );
388 v3_copy( board->wheel_positions[i], mlocal[3] );
389 m4x3_mul( root, mlocal, mlocal );
390
391 if( shader == k_board_shader_entity ){
392 m4x3_expand( mlocal, m4mdl );
393 m4x4_mul( cam->mtx_prev.pv, m4mdl, m4mdl );
394 shader_model_entity_uPvmPrev( m4mdl );
395 shader_model_entity_uMdl( mlocal );
396 }
397 else
398 shader_model_board_view_uMdl( mlocal );
399
400 mdl_draw_submesh( &board->wheels[i] );
401 }
402 }
403
404 PLAYER_API void player__render( camera *cam, player_instance *player )
405 {
406 shader_model_character_view_use();
407
408 glActiveTexture( GL_TEXTURE0 );
409 glBindTexture( GL_TEXTURE_2D, player->playermodel->texture );
410 shader_model_character_view_uTexMain( 0 );
411 shader_model_character_view_uCamera( cam->transform[3] );
412 shader_model_character_view_uPv( cam->mtx.pv );
413 shader_model_character_view_uTexSceneDepth( 1 );
414 render_fb_bind_texture( gpipeline.fb_main, 2, 1 );
415 v3f inverse;
416 render_fb_inverse_ratio( gpipeline.fb_main, inverse );
417 inverse[2] = main_camera.farz-main_camera.nearz;
418
419 shader_model_character_view_uInverseRatioDepth( inverse );
420 render_fb_inverse_ratio( NULL, inverse );
421 inverse[2] = cam->farz-cam->nearz;
422 shader_model_character_view_uInverseRatioMain( inverse );
423
424 world_instance *world = get_active_world();
425 world_link_lighting_ub( world, _shader_model_character_view.id );
426 world_bind_position_texture( world, _shader_model_character_view.id,
427 _uniform_model_character_view_g_world_depth, 2 );
428 world_bind_light_array( world, _shader_model_character_view.id,
429 _uniform_model_character_view_uLightsArray, 3 );
430 world_bind_light_index( world, _shader_model_character_view.id,
431 _uniform_model_character_view_uLightsIndex, 4 );
432
433 glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms,
434 player->playeravatar->sk.bone_count,
435 0,
436 (float *)player->playeravatar->sk.final_mtx );
437
438 mesh_bind( &player->playermodel->mesh );
439 mesh_draw( &player->playermodel->mesh );
440
441 struct player_board *board = player->board;
442
443 render_board( cam, world, board, player->playeravatar->sk.final_mtx[
444 player->playeravatar->id_board],
445 k_board_shader_player );
446 }
447
448 #endif /* PLAYER_RENDER_C */
Skaterift source tree