player.c

   1 #ifndef PLAYER_C
   2 #define PLAYER_C
   3
   4 #include "player.h"
   5 #include "camera.h"
   6 #include "player_model.h"
   7
   8 PLAYER_API
   9 void player__debugtext( int size, const char *fmt, ... )
  10 {
  11         char buffer[ 1024 ];
  12
  13    va_list args;
  14    va_start( args, fmt );
  15    vsnprintf( buffer, 1024, fmt, args );
  16    va_end( args );
  17
  18    ui_text( vg_uictx.cursor, buffer, size, k_text_align_right );
  19         vg_uictx.cursor[1] += 14*size;
  20 }
  21
  22 /*
  23  * Init
  24  */
  25 PLAYER_API
  26 void player__create( player_instance *inst )
  27 {
  28    static int only_once = 0;
  29    assert( only_once == 0 );
  30    only_once ++;
  31
  32    inst->input_js1h = vg_create_named_input( "steer-h", k_input_type_axis );
  33    inst->input_js1v = vg_create_named_input( "steer-v", k_input_type_axis );
  34    inst->input_grab = vg_create_named_input( "grab",    k_input_type_axis_norm);
  35    inst->input_js2h = vg_create_named_input( "grab-h",  k_input_type_axis );
  36    inst->input_js2v = vg_create_named_input( "grab-v",  k_input_type_axis );
  37    inst->input_jump = vg_create_named_input( "jump",    k_input_type_button );
  38    inst->input_push = vg_create_named_input( "push",    k_input_type_button );
  39    inst->input_walk = vg_create_named_input( "walk",    k_input_type_button );
  40    inst->input_walkh= vg_create_named_input( "walk-h",  k_input_type_axis );
  41    inst->input_walkv= vg_create_named_input( "walk-v",  k_input_type_axis );
  42    inst->input_use  = vg_create_named_input( "use",     k_input_type_button );
  43    inst->input_reset= vg_create_named_input( "reset",   k_input_type_button );
  44    inst->input_camera=vg_create_named_input( "camera",  k_input_type_button );
  45
  46    const char *default_cfg[] =
  47    {
  48       "bind  steer-h gp-ls-h",
  49       "bind -steer-h a",
  50       "bind +steer-h d",
  51
  52       "bind  steer-v gp-ls-v",
  53       "bind -steer-v w",
  54       "bind +steer-v s",
  55
  56       "bind  grab gp-rt",
  57       "bind +grab shift",
  58       "bind  grab-h gp-rs-h",
  59       "bind  grab-v gp-rs-v",
  60
  61       "bind jump space",
  62       "bind jump gp-a",
  63
  64       "bind push gp-b",
  65       "bind push w",
  66
  67       "bind walk shift",
  68       "bind walk gp-ls",
  69
  70       "bind  walk-h  gp-ls-h",
  71       "bind  walk-v -gp-ls-v",
  72       "bind +walk-h d",
  73       "bind -walk-h a",
  74       "bind +walk-v w",
  75       "bind -walk-v s",
  76
  77       "bind reset gp-lb",
  78       "bind reset r",
  79
  80       "bind use gp-y",
  81       "bind use e",
  82       "bind camera c"
  83    };
  84
  85    for( int i=0; i<vg_list_size(default_cfg); i++ )
  86       vg_execute_console_input(default_cfg[i]);
  87
  88    v3_zero( inst->rb.co );
  89    v3_zero( inst->rb.w );
  90    v3_zero( inst->rb.v );
  91    q_identity( inst->rb.q );
  92    m4x3_identity( inst->rb.to_world );
  93    m4x3_identity( inst->rb.to_local );
  94 }
  95
  96 /*
  97  * Appearence
  98  */
  99 PLAYER_API
 100 void player__use_avatar( player_instance *player, struct player_avatar *av )
 101 {
 102    player->playeravatar = av;
 103    player_setup_ragdoll_from_avatar( &player->ragdoll, av );
 104 }
 105
 106 PLAYER_API
 107 void player__use_mesh( player_instance *player, glmesh *mesh )
 108 {
 109    player->playermesh = mesh;
 110 }
 111
 112 PLAYER_API
 113 void player__use_texture( player_instance *player, vg_tex2d *tex )
 114 {
 115    player->playertex = tex;
 116 }
 117
 118 PLAYER_API
 119 void player__bind( player_instance *player )
 120 {
 121    player__skate_bind( player );
 122    player__walk_bind( player );
 123 }
 124
 125 /*
 126  * Gameloop events
 127  * ----------------------------------------------------------------------------
 128  */
 129 PLAYER_API
 130 void player__pre_update( player_instance *player )
 131 {
 132    if( vg_input_button_down( player->input_camera ) )
 133    {
 134       if( player->camera_mode == k_cam_firstperson )
 135          player->camera_mode = k_cam_thirdperson;
 136       else
 137          player->camera_mode = k_cam_firstperson;
 138    }
 139
 140    if( _player_pre_update[ player->subsystem ] )
 141       _player_pre_update[ player->subsystem ]( player );
 142 }
 143
 144 PLAYER_API
 145 void player__update( player_instance *player )
 146 {
 147    if( _player_update[ player->subsystem ] )
 148       _player_update[ player->subsystem ]( player );
 149 }
 150
 151 PLAYER_API
 152 void player__post_update( player_instance *player )
 153 {
 154    if( _player_post_update[ player->subsystem ] )
 155       _player_post_update[ player->subsystem ]( player );
 156 }
 157
 158 VG_STATIC void player_apply_transport_to_cam( m4x3f transport )
 159 {
 160    /* FIXME: Applies to main_camera directly! */
 161
 162    /* Pre-emptively edit the camera matrices so that the motion vectors
 163     * are correct */
 164    m4x3f transport_i;
 165    m4x4f transport_4;
 166    m4x3_invert_affine( transport, transport_i );
 167    m4x3_expand( transport_i, transport_4 );
 168    m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
 169    m4x4_mul( main_camera.mtx.v,  transport_4, main_camera.mtx.v );
 170 }
 171
 172 /*
 173  * Applies gate transport to a player_interface
 174  */
 175 PLAYER_API
 176 void player__pass_gate( player_instance *player, teleport_gate *gate )
 177 {
 178    player->gate_waiting = gate;
 179
 180    /* TODO: Add back other logic thats normally here */
 181 }
 182
 183 VG_STATIC void player_camera_portal_correction( player_instance *player )
 184 {
 185    if( player->gate_waiting )
 186    {
 187       /* construct plane equation for reciever gate */
 188       v4f plane;
 189       v3_copy( player->gate_waiting->recv_to_world[2], plane );
 190       plane[3] = v3_dot( plane, player->gate_waiting->recv_to_world[3] );
 191
 192       /* check camera polarity */
 193       if( v3_dot( player->cam.pos, plane ) < plane[3] )
 194       {
 195          vg_success( "Plane cleared\n" );
 196          player_apply_transport_to_cam( player->gate_waiting->transport );
 197          player->gate_waiting = NULL;
 198       }
 199       else
 200       {
 201          /* de-transform camera and player back */
 202          m4x3f inverse;
 203          m4x3_invert_affine( player->gate_waiting->transport, inverse );
 204          m4x3_mulv( inverse, player->cam.pos, player->cam.pos );
 205
 206          /* TODO: Find robust method for this */
 207          v3f fwd_dir = { cosf(player->cam.angles[0]),
 208                          0.0f,
 209                          sinf(player->cam.angles[0])};
 210          m3x3_mulv( inverse, fwd_dir, fwd_dir );
 211          player->cam.angles[0] = atan2f( fwd_dir[2], fwd_dir[0] );
 212
 213          struct skeleton *sk = &player->playeravatar->sk;
 214          skeleton_apply_transform( sk, inverse );
 215       }
 216    }
 217 }
 218
 219 VG_STATIC void player__pre_render( player_instance *player )
 220 {
 221    if( _player_animate[ player->subsystem ] )
 222    {
 223       player_animation res;
 224       _player_animate[ player->subsystem ]( player, &res );
 225
 226       /* TODO: eventually, blending code goes here */
 227
 228       m4x3f transform;
 229       q_m3x3( res.root_q, transform );
 230       v3_copy( res.root_co, transform[3] );
 231
 232       struct skeleton *sk = &player->playeravatar->sk;
 233
 234       skeleton_apply_pose( sk, res.pose, k_anim_apply_defer_ik );
 235       skeleton_apply_ik_pass( sk );
 236       skeleton_apply_pose( sk, res.pose, k_anim_apply_deffered_only );
 237       skeleton_apply_inverses( sk );
 238       skeleton_apply_transform( sk, transform );
 239       skeleton_debug( sk );
 240    }
 241
 242    if( _player_post_animate[ player->subsystem ] )
 243       _player_post_animate[ player->subsystem ]( player );
 244
 245    /* TODO: eventually, blending code goes here */
 246
 247    float camera_blend_target = 1.0f;
 248    if( player->camera_mode == k_cam_firstperson )
 249       camera_blend_target = 0.0f;
 250
 251    player->camera_type_blend = vg_lerpf( player->camera_type_blend,
 252                                          camera_blend_target,
 253                                          5.0f * vg.frame_delta );
 254
 255    float t = player->camera_type_blend;
 256    camera_lerp_angles( player->cam1.angles, player->cam3.angles,
 257                        t, player->cam.angles );
 258    v3_lerp( player->cam1.co, player->cam3.co, t, player->cam.pos );
 259    player->cam.fov = vg_lerpf( 118.0f, 90.0f, t );
 260
 261    player_camera_portal_correction( player );
 262 }
 263
 264 PLAYER_API void player__render( camera *cam, player_instance *player )
 265 {
 266    shader_viewchar_use();
 267    vg_tex2d_bind( player->playertex, 0 );
 268    shader_viewchar_uTexMain( 0 );
 269    shader_viewchar_uCamera( cam->transform[3] );
 270    shader_viewchar_uPv( cam->mtx.pv );
 271    shader_link_standard_ub( _shader_viewchar.id, 2 );
 272    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
 273                          player->playeravatar->sk.bone_count,
 274                          0,
 275                          (float *)player->playeravatar->sk.final_mtx );
 276
 277    mesh_bind( player->playermesh );
 278    mesh_draw( player->playermesh );
 279 }
 280
 281 PLAYER_API void player__im_gui( player_instance *player )
 282 {
 283    vg_uictx.cursor[0] = vg.window_x - 200;
 284    vg_uictx.cursor[1] = 0;
 285    vg_uictx.cursor[2] = 200;
 286    vg_uictx.cursor[3] = 200;
 287
 288    struct ui_vert *b = ui_fill_rect( vg_uictx.cursor, 0x70000000 );
 289
 290    vg_uictx.cursor[0] = vg.window_x;
 291
 292    if( _player_im_gui[ player->subsystem ] )
 293       _player_im_gui[ player->subsystem ]( player );
 294
 295    b[2].co[1] = vg_uictx.cursor[1];
 296    b[3].co[1] = vg_uictx.cursor[1];
 297 }
 298
 299 PLAYER_API void player__spawn( player_instance *player,
 300                               struct respawn_point *rp )
 301 {
 302    v3_copy( rp->co, player->rb.co );
 303    v3_zero( player->rb.v );
 304    v3_zero( player->rb.w );
 305    q_identity( player->rb.q );
 306    rb_update_transform( &player->rb );
 307
 308    if( _player_reset[ player->subsystem ] )
 309       _player_reset[ player->subsystem ]( player, rp );
 310 }
 311
 312
 313 PLAYER_API void player__kill( player_instance *player )
 314 {
 315
 316 }
 317
 318 #endif /* PLAYER_C */