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 VG_STATIC void gate_rotate_angles( teleport_gate *gate, v3f angles, v3f d )
 173 {
 174    v3f fwd_dir = { cosf(angles[0]),
 175                    0.0f,
 176                    sinf(angles[0])};
 177    m3x3_mulv( gate->transport, fwd_dir, fwd_dir );
 178
 179    v3_copy( angles, d );
 180    d[0] = atan2f( fwd_dir[2], fwd_dir[0] );
 181 }
 182
 183 /*
 184  * Applies gate transport to a player_interface
 185  */
 186 PLAYER_API
 187 void player__pass_gate( player_instance *player, teleport_gate *gate )
 188 {
 189    player->gate_waiting = gate;
 190
 191    /* TODO: Add back other logic thats normally here */
 192
 193 #if 0
 194    m4x3_mulv( gate->transport, player->follow_pos, player->follow_pos );
 195    gate_rotate_angles( gate, player->follow_angles, player->follow_angles );
 196 #endif
 197 }
 198
 199 VG_STATIC void player__pre_render( player_instance *player )
 200 {
 201    if( _player_animate[ player->subsystem ] )
 202    {
 203       player_animation res;
 204       _player_animate[ player->subsystem ]( player, &res );
 205
 206       /* TODO: eventually, blending code goes here */
 207
 208       m4x3f transform;
 209       q_m3x3( res.root_q, transform );
 210       v3_copy( res.root_co, transform[3] );
 211
 212       struct skeleton *sk = &player->playeravatar->sk;
 213
 214       skeleton_apply_pose( sk, res.pose, k_anim_apply_defer_ik );
 215       skeleton_apply_ik_pass( sk );
 216       skeleton_apply_pose( sk, res.pose, k_anim_apply_deffered_only );
 217       skeleton_apply_inverses( sk );
 218       skeleton_apply_transform( sk, transform );
 219       skeleton_debug( sk );
 220    }
 221
 222    if( _player_post_animate[ player->subsystem ] )
 223       _player_post_animate[ player->subsystem ]( player );
 224
 225    player__cam_iterate( player );
 226 }
 227
 228 PLAYER_API void player__render( camera *cam, player_instance *player )
 229 {
 230    shader_viewchar_use();
 231    vg_tex2d_bind( player->playertex, 0 );
 232    shader_viewchar_uTexMain( 0 );
 233    shader_viewchar_uCamera( cam->transform[3] );
 234    shader_viewchar_uPv( cam->mtx.pv );
 235    shader_link_standard_ub( _shader_viewchar.id, 2 );
 236    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
 237                          player->playeravatar->sk.bone_count,
 238                          0,
 239                          (float *)player->playeravatar->sk.final_mtx );
 240
 241    mesh_bind( player->playermesh );
 242    mesh_draw( player->playermesh );
 243 }
 244
 245 PLAYER_API void player__im_gui( player_instance *player )
 246 {
 247    vg_uictx.cursor[0] = vg.window_x - 200;
 248    vg_uictx.cursor[1] = 0;
 249    vg_uictx.cursor[2] = 200;
 250    vg_uictx.cursor[3] = 200;
 251
 252    struct ui_vert *b = ui_fill_rect( vg_uictx.cursor, 0x70000000 );
 253
 254    vg_uictx.cursor[0] = vg.window_x;
 255
 256    player__debugtext( 1, "%.2f %.2f %.2f", player->cam.pos[0],
 257                                            player->cam.pos[1],
 258                                            player->cam.pos[2] );
 259    player__debugtext( 1, "%.2f %.2f %.2f (%.2f)",
 260                                            player->cam.angles[0],
 261                                            player->cam.angles[1],
 262                                            player->cam.angles[2],
 263                                            player->cam.fov);
 264    player__debugtext( 1, "C/K %.2f %.2f (%.2f)",
 265                               player->cam_velocity_coefficient_smooth,
 266                               player->cam_velocity_constant_smooth,
 267                               player->cam_velocity_influence_smooth );
 268
 269    if( _player_im_gui[ player->subsystem ] )
 270       _player_im_gui[ player->subsystem ]( player );
 271
 272    b[2].co[1] = vg_uictx.cursor[1];
 273    b[3].co[1] = vg_uictx.cursor[1];
 274 }
 275
 276 PLAYER_API void player__spawn( player_instance *player,
 277                               struct respawn_point *rp )
 278 {
 279    v3_copy( rp->co, player->rb.co );
 280    v3_zero( player->rb.v );
 281    v3_zero( player->rb.w );
 282    q_identity( player->rb.q );
 283    rb_update_transform( &player->rb );
 284
 285    if( _player_reset[ player->subsystem ] )
 286       _player_reset[ player->subsystem ]( player, rp );
 287 }
 288
 289
 290 PLAYER_API void player__kill( player_instance *player )
 291 {
 292
 293 }
 294
 295 #endif /* PLAYER_C */