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 #include "ent_skateshop.h"
   9 #include "audio.h"
  10
  11 #include "shaders/model_character_view.h"
  12 #include "shaders/model_board_view.h"
  13 #include "shaders/model_entity.h"
  14
  15 VG_STATIC void player_avatar_load( struct player_avatar *av, const char *path )
  16 {
  17    mdl_open( &av->meta, path, vg_mem.rtmemory );
  18    mdl_load_metadata_block( &av->meta, vg_mem.rtmemory );
  19    mdl_load_animation_block( &av->meta, vg_mem.rtmemory );
  20    mdl_close( &av->meta );
  21
  22    struct skeleton *sk = &av->sk;
  23    skeleton_setup( sk, vg_mem.rtmemory, &av->meta );
  24
  25    av->id_hip        = skeleton_bone_id( sk, "hips" );
  26    av->id_ik_hand_l  = skeleton_bone_id( sk, "hand.IK.L" );
  27    av->id_ik_hand_r  = skeleton_bone_id( sk, "hand.IK.R" );
  28    av->id_ik_elbow_l = skeleton_bone_id( sk, "elbow.L" );
  29    av->id_ik_elbow_r = skeleton_bone_id( sk, "elbow.R" );
  30    av->id_head       = skeleton_bone_id( sk, "head" );
  31    av->id_ik_foot_l  = skeleton_bone_id( sk, "foot.IK.L" );
  32    av->id_ik_foot_r  = skeleton_bone_id( sk, "foot.IK.R" );
  33    av->id_board      = skeleton_bone_id( sk, "board" );
  34    av->id_wheel_l    = skeleton_bone_id( sk, "wheel.L" );
  35    av->id_wheel_r    = skeleton_bone_id( sk, "wheel.R" );
  36    av->id_ik_knee_l  = skeleton_bone_id( sk, "knee.L" );
  37    av->id_ik_knee_r  = skeleton_bone_id( sk, "knee.R" );
  38 }
  39
  40 /* TODO: Standard model load */
  41
  42 VG_STATIC void dynamic_model_load( mdl_context *ctx,
  43                                    struct dynamic_model_1texture *mdl,
  44                                    const char *path )
  45 {
  46    if( !mdl_arrcount( &ctx->textures ) )
  47       vg_fatal_error( "No texture in model" );
  48
  49    mdl_texture *tex0 = mdl_arritm( &ctx->textures, 0 );
  50    void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
  51    mdl_fread_pack_file( ctx, &tex0->file, data );
  52
  53    vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
  54                             VG_TEX2D_NEAREST|VG_TEX2D_CLAMP,
  55                             &mdl->texture );
  56
  57    mdl_async_load_glmesh( ctx, &mdl->mesh );
  58 }
  59
  60 VG_STATIC void dynamic_model_unload( struct dynamic_model_1texture *mdl ){
  61    mesh_free( &mdl->mesh );
  62    glDeleteTextures( 1, &mdl->texture );
  63 }
  64
  65 /* TODO: allow error handling */
  66 VG_STATIC void player_board_load( struct player_board *board,
  67                                   const char *path ){
  68
  69    vg_linear_clear( vg_mem.scratch );
  70
  71    mdl_context ctx;
  72    mdl_open( &ctx, path, vg_mem.scratch );
  73    mdl_load_metadata_block( &ctx, vg_mem.scratch );
  74
  75    dynamic_model_load( &ctx, &board->mdl, path );
  76
  77    mdl_array_ptr markers;
  78    mdl_load_array( &ctx, &markers, "ent_marker", vg_mem.scratch );
  79
  80    /* TODO: you get put into a new section, the above is standard mdl loads. */
  81    for( int i=0; i<4; i++ )
  82       board->wheels[i].indice_count = 0;
  83    for( int i=0; i<2; i++ )
  84       board->trucks[i].indice_count = 0;
  85    board->board.indice_count = 0;
  86
  87    for( u32 i=0; i<mdl_arrcount(&ctx.meshs); i++ ){
  88       mdl_mesh *mesh = mdl_arritm( &ctx.meshs, i );
  89
  90       if( mdl_entity_id_type( mesh->entity_id ) != k_ent_marker )
  91          continue;
  92
  93       u32 index = mdl_entity_id_id( mesh->entity_id );
  94       ent_marker *marker = mdl_arritm( &markers, index );
  95
  96       mdl_submesh *sm0 = mdl_arritm( &ctx.submeshs, mesh->submesh_start );
  97
  98       const char *alias = mdl_pstr( &ctx, marker->pstr_alias );
  99       u32 lr = marker->transform.co[0] > 0.0f? 1: 0,
 100           fb = marker->transform.co[2] > 0.0f? 0: 1;
 101
 102       if( !strcmp( alias, "wheel" ) ){
 103          u32 id = fb<<1 | lr;
 104          board->wheels[ id ] = *sm0;
 105          v3_copy( marker->transform.co, board->wheel_positions[ id ] );
 106       }
 107       else if( !strcmp( alias, "board" ) ){
 108          board->board = *sm0;
 109          v3_copy( marker->transform.co, board->board_position );
 110       }
 111       else if( !strcmp( alias, "truck" ) ){
 112          board->trucks[ fb ] = *sm0;
 113          v3_copy( marker->transform.co, board->truck_positions[ fb ] );
 114       }
 115    }
 116
 117    mdl_close( &ctx );
 118 }
 119
 120 VG_STATIC void player_board_unload( struct player_board *board ){
 121    dynamic_model_unload( &board->mdl );
 122 }
 123
 124 VG_STATIC void player_model_load( struct player_model *board, const char *path){
 125    vg_linear_clear( vg_mem.scratch );
 126
 127    mdl_context ctx;
 128    mdl_open( &ctx, path, vg_mem.scratch );
 129    mdl_load_metadata_block( &ctx, vg_mem.scratch );
 130
 131    dynamic_model_load( &ctx, &board->mdl, path );
 132
 133    mdl_close( &ctx );
 134 }
 135
 136 VG_STATIC void player_model_unload( struct player_model *board ){
 137    dynamic_model_unload( &board->mdl );
 138 }
 139
 140 VG_STATIC void player__pre_render( player_instance *player )
 141 {
 142    if( _player_animate[ player->subsystem ] ){
 143       player_animation res;
 144       res.type = k_player_animation_type_fk;
 145
 146       _player_animate[ player->subsystem ]( player, &res );
 147
 148       m4x3f transform;
 149       q_m3x3( res.root_q, transform );
 150       v3_copy( res.root_co, transform[3] );
 151
 152       struct skeleton *sk = &player->playeravatar->sk;
 153
 154       if( player->holdout_time > 0.0f ){
 155          skeleton_lerp_pose( sk, res.pose, player->holdout_pose,
 156                                            player->holdout_time, res.pose );
 157          player->holdout_time -= vg.time_frame_delta * 2.0f;
 158       }
 159
 160       if( res.type == k_player_animation_type_fk ){
 161          skeleton_apply_pose( sk, res.pose, k_anim_apply_defer_ik );
 162          skeleton_apply_ik_pass( sk );
 163          skeleton_apply_pose( sk, res.pose, k_anim_apply_deffered_only );
 164          skeleton_apply_inverses( sk );
 165          skeleton_apply_transform( sk, transform );
 166       }
 167       else {
 168          skeleton_apply_pose( sk, res.pose, k_anim_apply_absolute );
 169       }
 170
 171       skeleton_debug( sk );
 172    }
 173
 174    if( _player_post_animate[ player->subsystem ] )
 175       _player_post_animate[ player->subsystem ]( player );
 176
 177    struct player_avatar *av = player->playeravatar;
 178    struct player_board *board =
 179       addon_cache_item_if_loaded( k_addon_type_board,
 180                                   player->board_view_slot );
 181
 182    v3f vp0, vp1;
 183
 184    if( board ){
 185       v3_copy((v3f){0.0f,0.1f, board->truck_positions[0][2]}, vp0 );
 186       v3_copy((v3f){0.0f,0.1f, board->truck_positions[1][2]}, vp1 );
 187    }
 188    else{
 189       v3_zero( vp0 );
 190       v3_zero( vp1 );
 191    }
 192
 193    struct ub_world_lighting *ubo = &world_current_instance()->ub_lighting;
 194    m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp0, ubo->g_board_0 );
 195    m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp1, ubo->g_board_1 );
 196
 197    if( player->immobile ){
 198       player__cam_iterate( player );
 199       return;
 200    }
 201
 202 #if 0
 203    if( player->rewinding ){
 204       if( player->rewind_time <= 0.0f ){
 205          double taken = vg.time - player->rewind_start;
 206          vg_success( "Rewind took (rt, pt, tl): %f, %f, %f\n",
 207                            taken, player->rewind_predicted_time,
 208                            player->rewind_total_length );
 209
 210          player->rewinding = 0;
 211          player->rewind_length = 1;
 212          player->rewind_total_length = 0.0f;
 213          player->rewind_accum = 0.0f;
 214          world_render.sky_target_rate = 1.0;
 215          world_static.time = world_static.last_use;
 216       }
 217       else{
 218          world_render.sky_target_rate = -100.0;
 219
 220          float budget         = vg.time_delta,
 221                overall_length = player->rewind_length;
 222
 223          for( int i=0; (i<10)&&(player->rewind_time>0.0f)&&(budget>0.0f); i++ ){
 224             /* Interpolate frames */
 225             int i0 = floorf( player->rewind_time ),
 226                 i1 = VG_MIN( i0+1, player->rewind_length-1 );
 227
 228             struct rewind_frame *fr =  &player->rewind_buffer[i0],
 229                                 *fr1 = &player->rewind_buffer[i1];
 230
 231             float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
 232                   subl = vg_fractf( player->rewind_time ) + 0.001f,
 233
 234                   sramp = 3.0f-(1.0f/(0.4f+0.4f*player->rewind_time)),
 235                   speed = sramp*28.0f + 0.5f*player->rewind_time,
 236                   mod  = speed * (budget / dist),
 237
 238                   advl = vg_minf( mod, subl ),
 239                   advt = (advl / mod) * budget;
 240
 241             player->dist_accum += speed * advt;
 242             player->rewind_time -= advl;
 243             budget -= advt;
 244          }
 245
 246          player->rewind_time = vg_maxf( 0.0f, player->rewind_time );
 247
 248          float current_time = vg.time - player->rewind_start,
 249                remaining    = player->rewind_predicted_time - current_time;
 250
 251          if( player->rewind_sound_wait ){
 252             if( player->rewind_predicted_time >= 6.5f ){
 253                if( remaining <= 6.5f ){
 254                   audio_lock();
 255                   audio_oneshot( &audio_rewind[3], 1.0f, 0.0f );
 256                   audio_unlock();
 257                   player->rewind_sound_wait = 0;
 258                }
 259             }
 260             else if( player->rewind_predicted_time >= 2.5f ){
 261                if( remaining <= 2.5f ){
 262                   audio_lock();
 263                   audio_oneshot( &audio_rewind[2], 1.0f, 0.0f );
 264                   audio_unlock();
 265                   player->rewind_sound_wait = 0;
 266                }
 267             }
 268             else if( player->rewind_predicted_time >= 1.5f ){
 269                if( remaining <= 1.5f ){
 270                   audio_lock();
 271                   audio_oneshot( &audio_rewind[1], 1.0f, 0.0f );
 272                   audio_unlock();
 273                   player->rewind_sound_wait = 0;
 274                }
 275             }
 276          }
 277
 278          int i0 = floorf( player->rewind_time ),
 279              i1 = VG_MIN( i0+1, player->rewind_length-1 );
 280
 281          struct rewind_frame *fr =  &player->rewind_buffer[i0],
 282                              *fr1 = &player->rewind_buffer[i1];
 283
 284          float sub = vg_fractf(player->rewind_time);
 285
 286          v3_lerp( fr->pos, fr1->pos, sub, player->cam_override_pos );
 287          player->cam_override_angles[0] =
 288             vg_alerpf( fr->ang[0], fr1->ang[0], sub );
 289          player->cam_override_angles[1] =
 290             vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
 291          player->cam_override_fov = player->cam.fov;
 292
 293          float blend = player->rewind_time * 0.25f;
 294          player->cam_override_strength = vg_clampf( blend, 0.0f, 1.0f );
 295       }
 296    }
 297    else player->cam_override_strength = 0.0f;
 298 #else
 299    player->cam_override_strength = 0.0f;
 300 #endif
 301
 302    player__cam_iterate( player );
 303
 304    /* dev playbacker */
 305    if( k_replay_test ){
 306       f64 speed = 1.0;
 307       f64 target = player->replay.cursor;
 308
 309       if( vg_getkey( SDLK_9 ) )
 310          target -= vg.time_frame_delta * speed;
 311       if( vg_getkey( SDLK_0 ) )
 312          target += vg.time_frame_delta * speed;
 313
 314       replay_seek( &player->replay, target );
 315
 316       player_animation res;
 317       replay_frame *frame = player->replay.cursor_frame;
 318
 319       if( frame ){
 320          memcpy( &res, &frame->anim, sizeof(frame->anim) );
 321          memcpy( &frame->board_pose, &player->board_pose,
 322                  sizeof(player->board_pose) );
 323       }
 324       else return;
 325
 326       struct skeleton *sk = &player->playeravatar->sk;
 327       skeleton_apply_pose( sk, res.pose, k_anim_apply_absolute );
 328    }
 329    else {
 330       /* replay recorder */
 331       replay_buffer *replay = &player->replay;
 332       f64 delta = vg.time - replay->cursor;
 333       if( delta > (1.0/30.0) ){
 334          replay->cursor = vg.time;
 335          replay_frame *frame = replay_newframe( replay );
 336
 337          player_animation *res = &frame->anim;
 338          v3_zero( res->root_co );
 339          q_identity( res->root_q );
 340          res->type = k_player_animation_type_absolute;
 341
 342          struct skeleton *sk = &player->playeravatar->sk;
 343          skeleton_decompose_mtx_absolute( sk, res->pose );
 344
 345          memcpy( &frame->board_pose, &player->board_pose,
 346                   sizeof(player->board_pose) );
 347          frame->time = vg.time;
 348       }
 349    }
 350 }
 351
 352 VG_STATIC void render_board( camera *cam, world_instance *world,
 353                              struct player_board *board, m4x3f root,
 354                              struct board_pose *pose,
 355                              enum board_shader shader )
 356 {
 357    if( !board ) return;
 358
 359    v3f inverse;
 360
 361    glActiveTexture( GL_TEXTURE0 );
 362    glBindTexture( GL_TEXTURE_2D, board->mdl.texture );
 363
 364    if( shader == k_board_shader_player ){
 365       shader_model_board_view_use();
 366       shader_model_board_view_uTexMain( 0 );
 367       shader_model_board_view_uCamera( cam->transform[3] );
 368       shader_model_board_view_uPv( cam->mtx.pv );
 369       shader_model_board_view_uTexSceneDepth( 1 );
 370       render_fb_bind_texture( gpipeline.fb_main, 2, 1 );
 371
 372       render_fb_inverse_ratio( gpipeline.fb_main, inverse );
 373
 374       inverse[2] = main_camera.farz-main_camera.nearz;
 375
 376       shader_model_board_view_uInverseRatioDepth( inverse );
 377       render_fb_inverse_ratio( NULL, inverse );
 378       inverse[2] = cam->farz-cam->nearz;
 379       shader_model_board_view_uInverseRatioMain( inverse );
 380
 381       world_link_lighting_ub( world, _shader_model_board_view.id );
 382       world_bind_position_texture( world, _shader_model_board_view.id,
 383                                  _uniform_model_board_view_g_world_depth, 2 );
 384       world_bind_light_array( world, _shader_model_board_view.id,
 385                                  _uniform_model_board_view_uLightsArray, 3 );
 386       world_bind_light_index( world, _shader_model_board_view.id,
 387                                  _uniform_model_board_view_uLightsIndex, 4 );
 388    }
 389    else if( shader == k_board_shader_entity ){
 390       shader_model_entity_use();
 391       shader_model_entity_uTexMain( 0 );
 392       shader_model_entity_uCamera( cam->transform[3] );
 393       shader_model_entity_uPv( cam->mtx.pv );
 394
 395       world_link_lighting_ub( world, _shader_model_entity.id );
 396       world_bind_position_texture( world, _shader_model_entity.id,
 397                                  _uniform_model_entity_g_world_depth, 2 );
 398       world_bind_light_array( world, _shader_model_entity.id,
 399                                  _uniform_model_entity_uLightsArray, 3 );
 400       world_bind_light_index( world, _shader_model_entity.id,
 401                                  _uniform_model_entity_uLightsIndex, 4 );
 402    }
 403
 404    mesh_bind( &board->mdl.mesh );
 405
 406    m4x4f m4mdl;
 407
 408    if( board->board.indice_count ){
 409       m4x3f mlocal;
 410       m3x3_identity( mlocal );
 411
 412       mdl_keyframe kf;
 413       v3_zero( kf.co );
 414       q_identity( kf.q );
 415       v3_zero( kf.s );
 416
 417       v4f qroll;
 418       q_axis_angle( qroll, (v3f){0.0f,0.0f,1.0f}, pose->lean * 0.6f );
 419       keyframe_rotate_around( &kf, (v3f){0.0f,0.11f,0.0f},
 420                               (v3f){0.0f,0.0f,0.0f}, qroll );
 421
 422       v3_add( board->board_position, kf.co, mlocal[3] );
 423       q_m3x3( kf.q, mlocal );
 424
 425       m4x3_mul( root, mlocal, mlocal );
 426
 427       if( shader == k_board_shader_entity ){
 428          /* TODO: provide a way to supply previous mdl mtx? */
 429          m4x3_expand( mlocal, m4mdl );
 430          m4x4_mul( cam->mtx_prev.pv, m4mdl, m4mdl );
 431          shader_model_entity_uPvmPrev( m4mdl );
 432          shader_model_entity_uMdl( mlocal );
 433       }
 434       else
 435          shader_model_board_view_uMdl( mlocal );
 436
 437       mdl_draw_submesh( &board->board );
 438    }
 439
 440    for( int i=0; i<2; i++ ){
 441       if( !board->trucks[i].indice_count )
 442          continue;
 443
 444       m4x3f mlocal;
 445       m3x3_identity( mlocal );
 446       v3_copy( board->truck_positions[i], mlocal[3] );
 447       m4x3_mul( root, mlocal, mlocal );
 448
 449       if( shader == k_board_shader_entity ){
 450          m4x3_expand( mlocal, m4mdl );
 451          m4x4_mul( cam->mtx_prev.pv, m4mdl, m4mdl );
 452          shader_model_entity_uPvmPrev( m4mdl );
 453          shader_model_entity_uMdl( mlocal );
 454       }
 455       else
 456          shader_model_board_view_uMdl( mlocal );
 457
 458       mdl_draw_submesh( &board->trucks[i] );
 459    }
 460
 461    for( int i=0; i<4; i++ ){
 462       if( !board->wheels[i].indice_count )
 463          continue;
 464
 465       m4x3f mlocal;
 466       m3x3_identity( mlocal );
 467       v3_copy( board->wheel_positions[i], mlocal[3] );
 468       m4x3_mul( root, mlocal, mlocal );
 469
 470       if( shader == k_board_shader_entity ){
 471          m4x3_expand( mlocal, m4mdl );
 472          m4x4_mul( cam->mtx_prev.pv, m4mdl, m4mdl );
 473          shader_model_entity_uPvmPrev( m4mdl );
 474          shader_model_entity_uMdl( mlocal );
 475       }
 476       else
 477          shader_model_board_view_uMdl( mlocal );
 478
 479       mdl_draw_submesh( &board->wheels[i] );
 480    }
 481 }
 482
 483 VG_STATIC void render_playermodel( camera *cam, world_instance *world,
 484                                    struct player_model *model,
 485                                    struct skeleton *skeleton ){
 486    if( !model ) return;
 487
 488    shader_model_character_view_use();
 489
 490         glActiveTexture( GL_TEXTURE0 );
 491         glBindTexture( GL_TEXTURE_2D, model->mdl.texture );
 492    shader_model_character_view_uTexMain( 0 );
 493    shader_model_character_view_uCamera( cam->transform[3] );
 494    shader_model_character_view_uPv( cam->mtx.pv );
 495    shader_model_character_view_uTexSceneDepth( 1 );
 496    render_fb_bind_texture( gpipeline.fb_main, 2, 1 );
 497    v3f inverse;
 498    render_fb_inverse_ratio( gpipeline.fb_main, inverse );
 499    inverse[2] = main_camera.farz-main_camera.nearz;
 500
 501    shader_model_character_view_uInverseRatioDepth( inverse );
 502    render_fb_inverse_ratio( NULL, inverse );
 503    inverse[2] = cam->farz-cam->nearz;
 504    shader_model_character_view_uInverseRatioMain( inverse );
 505
 506    world_link_lighting_ub( world, _shader_model_character_view.id );
 507    world_bind_position_texture( world, _shader_model_character_view.id,
 508                               _uniform_model_character_view_g_world_depth, 2 );
 509    world_bind_light_array( world, _shader_model_character_view.id,
 510                               _uniform_model_character_view_uLightsArray, 3 );
 511    world_bind_light_index( world, _shader_model_character_view.id,
 512                               _uniform_model_character_view_uLightsIndex, 4 );
 513
 514    glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms,
 515                          skeleton->bone_count,
 516                          0,
 517                          (float *)skeleton->final_mtx );
 518
 519    mesh_bind( &model->mdl.mesh );
 520    mesh_draw( &model->mdl.mesh );
 521 }
 522
 523 PLAYER_API void player__render( camera *cam, player_instance *player )
 524 {
 525    world_instance *world = world_current_instance();
 526    SDL_AtomicLock( &addon_system.sl_cache_using_resources );
 527
 528    struct player_model *model =
 529       addon_cache_item_if_loaded( k_addon_type_player,
 530                                   player->playermodel_view_slot );
 531
 532    if( !model ) model = &player->fallback_model;
 533    render_playermodel( cam, world, model, &player->playeravatar->sk );
 534
 535    struct player_board *board =
 536       addon_cache_item_if_loaded( k_addon_type_board,
 537                                   player->board_view_slot );
 538
 539    render_board( cam, world, board, player->playeravatar->sk.final_mtx[
 540                                     player->playeravatar->id_board],
 541                                     &player->board_pose,
 542                                     k_board_shader_player );
 543
 544    SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
 545 }
 546
 547 #endif /* PLAYER_RENDER_C */