player_interface.h

   1 #ifndef PLAYER_INTERFACE_H
   2 #define PLAYER_INTERFACE_H
   3
   4 #include "model.h"
   5 #include "camera.h"
   6 #include "rigidbody.h"
   7 #include "player_ragdoll.h"
   8 #include "player_model.h"
   9 #include "world.h"
  10
  11 typedef struct player_device     player_device;
  12 typedef struct player_interface  player_interface;
  13 typedef struct player_device_transition player_device_transition;
  14 typedef mdl_keyframe player_pose[32];
  15
  16 #define PLAYER_DEVICE_API VG_STATIC
  17
  18 struct player_interface
  19 {
  20    rigidbody rb;
  21    camera cam;
  22
  23    player_device *devices[ 8 ];
  24    u32 active_device,
  25        device_count;
  26
  27    /*
  28     * Camera management
  29     * ---------------------------
  30     */
  31    enum camera_mode
  32    {
  33       k_camera_mode_firstperson,
  34       k_camera_mode_thirdperson
  35    }
  36    camera_mode;
  37    float camera_type_blend;
  38
  39    teleport_gate *gate_waiting;
  40
  41    /*
  42     * Input
  43     * --------------------------------
  44     */
  45    struct input_binding *input_js1h,
  46                         *input_js1v,
  47                         *input_js2h,
  48                         *input_js2v,
  49                         *input_jump,
  50                         *input_push,
  51                         *input_walk,
  52                         *input_walkh,
  53                         *input_walkv,
  54                         *input_use,
  55                         *input_reset,
  56                         *input_grab,
  57                         *input_camera;
  58
  59    /*
  60     * Animation
  61     * --------------------------------------------------
  62     */
  63
  64    struct player_avatar  *playeravatar;
  65    glmesh                *playermesh;
  66    struct player_ragdoll  ragdoll;
  67 };
  68
  69 enum player_device_event_type
  70 {
  71    k_player_device_event_bind,
  72    k_player_device_event_respawn,
  73    k_player_device_event_custom_transition,
  74
  75    k_player_device_event_pre_update,
  76    k_player_device_event_update,
  77    k_player_device_event_post_update,
  78    k_player_device_event_animate,
  79    k_player_device_event_post_animate,
  80    k_player_device_event_debug_ui,
  81    k_player_device_event_restore_state,
  82 };
  83
  84 /* FIXME: yo */
  85 vg_tex2d tex_characters = { .path = "textures/ch_gradient.qoi" };
  86
  87 struct player_device
  88 {
  89    const char *name;
  90    int (* event )  ( player_device *dev, player_interface *player,
  91                      enum player_device_event_type ev, void *data );
  92
  93    void          *storage;
  94
  95    /* animation driven */
  96    player_pose    pose;
  97    v3f            pose_root_co;
  98    v4f            pose_root_q;
  99    camera         cam_1st, cam_3rd;
 100 };
 101
 102 VG_STATIC void player_interface_create_player( player_interface *inst )
 103 {
 104    static int only_once = 0;
 105    assert( only_once == 0 );
 106    only_once ++;
 107
 108    inst->input_js1h = vg_create_named_input( "steer-h", k_input_type_axis );
 109    inst->input_js1v = vg_create_named_input( "steer-v", k_input_type_axis );
 110    inst->input_grab = vg_create_named_input( "grab",    k_input_type_axis_norm);
 111    inst->input_js2h = vg_create_named_input( "grab-h",  k_input_type_axis );
 112    inst->input_js2v = vg_create_named_input( "grab-v",  k_input_type_axis );
 113    inst->input_jump = vg_create_named_input( "jump",    k_input_type_button );
 114    inst->input_push = vg_create_named_input( "push",    k_input_type_button );
 115    inst->input_walk = vg_create_named_input( "walk",    k_input_type_button );
 116    inst->input_walkh= vg_create_named_input( "walk-h",  k_input_type_axis );
 117    inst->input_walkv= vg_create_named_input( "walk-v",  k_input_type_axis );
 118    inst->input_use  = vg_create_named_input( "use",     k_input_type_button );
 119    inst->input_reset= vg_create_named_input( "reset",   k_input_type_button );
 120    inst->input_camera=vg_create_named_input( "camera",  k_input_type_button );
 121
 122    const char *default_cfg[] =
 123    {
 124       "bind  steer-h gp-ls-h",
 125       "bind -steer-h a",
 126       "bind +steer-h d",
 127
 128       "bind  steer-v gp-ls-v",
 129       "bind -steer-v w",
 130       "bind +steer-v s",
 131
 132       "bind  grab gp-rt",
 133       "bind +grab shift",
 134       "bind  grab-h gp-rs-h",
 135       "bind  grab-v gp-rs-v",
 136
 137       "bind jump space",
 138       "bind jump gp-a",
 139
 140       "bind push gp-b",
 141       "bind push w",
 142
 143       "bind walk shift",
 144       "bind walk gp-ls",
 145
 146       "bind  walk-h  gp-ls-h",
 147       "bind  walk-v -gp-ls-v",
 148       "bind +walk-h d",
 149       "bind -walk-h a",
 150       "bind +walk-v w",
 151       "bind -walk-v s",
 152
 153       "bind reset gp-lb",
 154       "bind reset r",
 155
 156       "bind use gp-y",
 157       "bind use e",
 158       "bind camera c"
 159    };
 160
 161    for( int i=0; i<vg_list_size(default_cfg); i++ )
 162       vg_execute_console_input(default_cfg[i]);
 163
 164    v3_zero( inst->rb.co );
 165    v3_zero( inst->rb.w );
 166    v3_zero( inst->rb.v );
 167    q_identity( inst->rb.q );
 168    m4x3_identity( inst->rb.to_world );
 169    m4x3_identity( inst->rb.to_local );
 170 }
 171
 172 PLAYER_DEVICE_API u32 player_get_device( player_interface *player,
 173                                          const char *name )
 174 {
 175    for( u32 i=0; i<player->device_count; i++ )
 176    {
 177       player_device *dev = player->devices[i];
 178       if( !strcmp( name, dev->name ) )
 179          return i;
 180    }
 181
 182    vg_fatal_exit_loop( "Invalid device name\n" );
 183    return -1;
 184 }
 185
 186 VG_STATIC void player_use_avatar( player_interface *player,
 187                                   struct player_avatar *av )
 188 {
 189    player->playeravatar = av;
 190    player_setup_ragdoll_from_avatar( &player->ragdoll, av );
 191 }
 192
 193 VG_STATIC void player_use_mesh( player_interface *player, glmesh *mesh )
 194 {
 195    player->playermesh = mesh;
 196 }
 197
 198 /* FIXME: Seperate concepts for binding and equip.
 199  */
 200 VG_STATIC void player_add_device( player_interface *player, player_device *dev )
 201 {
 202    if( player->device_count == vg_list_size( player->devices ) )
 203       vg_fatal_exit_loop( "Too many devices added\n" );
 204
 205    player->devices[ player->device_count ++ ] = dev;
 206
 207    assert( dev->event );
 208    assert( dev->storage );
 209
 210    vg_success( "Added player device '%s'\n", dev->name );
 211 }
 212
 213 VG_STATIC void player_bind( player_interface *player )
 214 {
 215    for( int i=0; i<player->device_count; i++ )
 216    {
 217       player_device *dev = player->devices[i];
 218       dev->event( dev, player, k_player_device_event_bind, NULL );
 219    }
 220 }
 221
 222 PLAYER_DEVICE_API void player_transition_to_device( player_interface *player,
 223                                                     u32 id, void *data )
 224 {
 225    assert( id < player->device_count );
 226
 227    player->active_device = id;
 228    player_device *dev = player->devices[ player->active_device ];
 229
 230    dev->event( dev, player, k_player_device_event_custom_transition, data );
 231    //dev->event( dev, player, k_player_device_event_pre_update, NULL );
 232 }
 233
 234 VG_STATIC void player_pre_update( player_interface *player )
 235 {
 236    if( vg_input_button_down( player->input_camera ) )
 237    {
 238       if( player->camera_mode == k_camera_mode_firstperson )
 239          player->camera_mode = k_camera_mode_thirdperson;
 240       else
 241          player->camera_mode = k_camera_mode_firstperson;
 242    }
 243
 244 #if 0
 245    if( vg_input_button_down( player->input_use ) )
 246       player->active_device ^= 0x1;
 247 #endif
 248
 249 #if 0
 250    v3_copy( player->rb.co, player->prev_position );
 251 #endif
 252
 253    player_device *dev = player->devices[ player->active_device ];
 254    dev->event( dev, player, k_player_device_event_pre_update, NULL );
 255 }
 256
 257 VG_STATIC void player_update( player_interface *player )
 258 {
 259    player_device *dev = player->devices[ player->active_device ];
 260    dev->event( dev, player, k_player_device_event_update, NULL );
 261 }
 262
 263 VG_STATIC void player_apply_transport_to_cam( m4x3f transport )
 264 {
 265    /* FIXME: Applies to main_camera directly! */
 266
 267    /* Pre-emptively edit the camera matrices so that the motion vectors
 268     * are correct */
 269    m4x3f transport_i;
 270    m4x4f transport_4;
 271    m4x3_invert_affine( transport, transport_i );
 272    m4x3_expand( transport_i, transport_4 );
 273    m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
 274    m4x4_mul( main_camera.mtx.v,  transport_4, main_camera.mtx.v );
 275 }
 276
 277 /*
 278  * Applies gate transport to a player_interface
 279  */
 280 PLAYER_DEVICE_API
 281 void player_pass_gate( player_interface *player, teleport_gate *gate )
 282 {
 283    player->gate_waiting = gate;
 284 }
 285
 286 VG_STATIC void player_post_update( player_interface *player )
 287 {
 288    player_device *dev = player->devices[ player->active_device ];
 289    dev->event( dev, player, k_player_device_event_post_update, NULL );
 290 }
 291
 292 VG_STATIC void player_pre_render( player_interface *player )
 293 {
 294    player_device *dev = player->devices[ player->active_device ];
 295    dev->event( dev, player, k_player_device_event_animate, NULL );
 296
 297    /* TODO: eventually, blending code goes here */
 298
 299    m4x3f transform;
 300    q_m3x3( dev->pose_root_q, transform );
 301    v3_copy( dev->pose_root_co, transform[3] );
 302
 303    struct skeleton *sk = &player->playeravatar->sk;
 304
 305    skeleton_apply_pose( sk, dev->pose, k_anim_apply_defer_ik );
 306    skeleton_apply_ik_pass( sk );
 307    skeleton_apply_pose( sk, dev->pose, k_anim_apply_deffered_only );
 308    skeleton_apply_inverses( sk );
 309    skeleton_apply_transform( sk, transform );
 310    skeleton_debug( sk );
 311
 312 #if 0
 313    if( player->dev.device->pose )
 314    {
 315       player->dev.device->pose( player, &player->dev, pose, transform );
 316
 317       struct skeleton *sk = &player->playeravatar->sk;
 318
 319       skeleton_apply_pose( sk, pose, k_anim_apply_defer_ik );
 320       skeleton_apply_ik_pass( sk );
 321       skeleton_apply_pose( sk, pose, k_anim_apply_deffered_only );
 322       skeleton_apply_inverses( sk );
 323       skeleton_apply_transform( sk, transform );
 324       skeleton_debug( sk );
 325    }
 326 #endif
 327
 328    dev->event( dev, player, k_player_device_event_post_animate, NULL );
 329
 330    /* TODO: eventually, blending code goes here */
 331
 332    float camera_blend_target = 1.0f;
 333    if( player->camera_mode == k_camera_mode_firstperson )
 334       camera_blend_target = 0.0f;
 335
 336    player->camera_type_blend = vg_lerpf( player->camera_type_blend,
 337                                          camera_blend_target,
 338                                          5.0f * vg.frame_delta );
 339
 340    float t = player->camera_type_blend;
 341    camera_lerp( &dev->cam_1st, &dev->cam_3rd, t, &player->cam );
 342    player->cam.fov = vg_lerpf( 118.0f, 90.0f, t );
 343
 344    if( player->gate_waiting )
 345    {
 346       /* construct plane equation for reciever gate */
 347       v4f plane;
 348       v3_copy( player->gate_waiting->recv_to_world[2], plane );
 349       plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
 350
 351       /* check camera polarity */
 352       if( v3_dot( player->cam.pos, plane ) < plane[3] )
 353       {
 354          vg_success( "Plane cleared\n" );
 355          player_apply_transport_to_cam( player->gate_waiting->transport );
 356          player->gate_waiting = NULL;
 357       }
 358       else
 359       {
 360          /* de-transform camera and player back */
 361          m4x3f inverse;
 362          m4x3_invert_affine( player->gate_waiting->transport, inverse );
 363          m4x3_mulv( inverse, player->cam.pos, player->cam.pos );
 364
 365          /* TODO: Find robust method for this */
 366          v3f fwd_dir = { cosf(player->cam.angles[0]),
 367                          0.0f,
 368                          sinf(player->cam.angles[0])};
 369          m3x3_mulv( inverse, fwd_dir, fwd_dir );
 370          player->cam.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
 371
 372          skeleton_apply_transform( sk, inverse );
 373       }
 374    }
 375
 376 #if 0
 377    v3_copy( player->dev.cam_1st.pos,    player->cam.pos );
 378    v3_copy( player->dev.cam_1st.angles, player->cam.angles );
 379    player->cam.fov = player->dev.cam_1st.fov;
 380 #endif
 381 }
 382
 383 VG_STATIC void player_render( camera *cam, player_interface *player )
 384 {
 385    shader_viewchar_use();
 386    vg_tex2d_bind( &tex_characters, 0 );
 387    shader_viewchar_uTexMain( 0 );
 388    shader_viewchar_uCamera( cam->transform[3] );
 389    shader_viewchar_uPv( cam->mtx.pv );
 390    shader_link_standard_ub( _shader_viewchar.id, 2 );
 391    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
 392                          player->playeravatar->sk.bone_count,
 393                          0,
 394                          (float *)player->playeravatar->sk.final_mtx );
 395
 396    mesh_bind( player->playermesh );
 397    mesh_draw( player->playermesh );
 398 }
 399
 400 VG_STATIC void player_debugtext( int size, const char *fmt, ... )
 401 {
 402         char buffer[ 1024 ];
 403
 404    va_list args;
 405    va_start( args, fmt );
 406    vsnprintf( buffer, 1024, fmt, args );
 407    va_end( args );
 408
 409    ui_text( vg_uictx.cursor, buffer, size, k_text_align_right );
 410         vg_uictx.cursor[1] += 14*size;
 411 }
 412
 413 VG_STATIC void player_ui( player_interface *player )
 414 {
 415    /* TODO: if debugger enabled */
 416    player_device *dev = player->devices[ player->active_device ];
 417
 418    vg_uictx.cursor[0] = vg.window_x - 200;
 419    vg_uictx.cursor[1] = 0;
 420    vg_uictx.cursor[2] = 200;
 421    vg_uictx.cursor[3] = 200;
 422
 423    struct ui_vert *b = ui_fill_rect( vg_uictx.cursor, 0x70000000 );
 424
 425    vg_uictx.cursor[0] = vg.window_x;
 426    dev->event( dev, player, k_player_device_event_debug_ui, NULL );
 427
 428    b[2].co[1] = vg_uictx.cursor[1];
 429    b[3].co[1] = vg_uictx.cursor[1];
 430 }
 431
 432 VG_STATIC void player_spawn( player_interface *player,
 433                              struct respawn_point *rp )
 434 {
 435    player_device *dev = player->devices[ player->active_device ];
 436    v3_copy( rp->co, player->rb.co );
 437 #if 0
 438    v3_copy( rp->co, player->prev_position );
 439 #endif
 440    v3_zero( player->rb.v );
 441    v3_zero( player->rb.w );
 442    q_identity( player->rb.q );
 443    rb_update_transform( &player->rb );
 444
 445    dev->event( dev, player, k_player_device_event_respawn, rp );
 446 }
 447
 448
 449 VG_STATIC void player_kill( player_interface *player )
 450 {
 451
 452 }
 453
 454 /*
 455  * Apply per render-frame mouse look from player to angles
 456  */
 457 PLAYER_DEVICE_API
 458 void player_look( player_interface *player, v3f angles )
 459 {
 460    angles[2] = 0.0f;
 461    v2_muladds( angles, vg.mouse_delta, 0.0025f, angles );
 462
 463    if( vg_input.controller_should_use_trackpad_look )
 464    {
 465       static v2f last_input;
 466       static v2f vel;
 467       static v2f vel_smooth;
 468
 469       v2f input = { player->input_js2h->axis.value,
 470                     player->input_js2v->axis.value };
 471
 472       if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) )
 473       {
 474          v2_sub( input, last_input, vel );
 475          v2_muls( vel, 1.0f/vg.time_delta, vel );
 476       }
 477       else
 478       {
 479          v2_zero( vel );
 480       }
 481
 482       v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
 483
 484       v2_muladds( angles, vel_smooth, vg.time_delta, angles );
 485       v2_copy( input, last_input );
 486    }
 487    else
 488    {
 489       angles[0] += player->input_js2h->axis.value * vg.time_delta * 4.0f;
 490       angles[1] += player->input_js2v->axis.value * vg.time_delta * 4.0f;
 491    }
 492
 493    angles[1] = vg_clampf( angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
 494 }
 495
 496 #endif /* PLAYER_INTERFACE_H */