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_attachment player_attachment;
  14 typedef mdl_keyframe player_pose[32];
  15
  16 struct player_interface
  17 {
  18    rigidbody rb;
  19    camera cam;
  20
  21    struct player_attachment
  22    {
  23       player_device *device;
  24       void          *storage;
  25    }
  26    dev;
  27
  28    struct input_binding *input_js1h,
  29                         *input_js1v,
  30                         *input_js2h,
  31                         *input_js2v,
  32                         *input_jump,
  33                         *input_push,
  34                         *input_walk,
  35                         *input_walkh,
  36                         *input_walkv,
  37                         *input_use,
  38                         *input_reset,
  39                         *input_grab;
  40
  41    v3f prev_position;
  42
  43    struct player_avatar  *playeravatar;
  44    glmesh                *playermesh;
  45    struct player_ragdoll  ragdoll;
  46 };
  47
  48 /* FIXME: yo */
  49 vg_tex2d tex_characters = { .path = "textures/ch_gradient.qoi" };
  50
  51 struct player_device
  52 {
  53    void (* bind )      ( player_interface *player, player_attachment *at );
  54    void (* pre_update) ( player_interface *player, player_attachment *at );
  55    void (* update)     ( player_interface *player, player_attachment *at );
  56    void (* post_update)( player_interface *player, player_attachment *at );
  57    void (* pose)       ( player_interface *player, player_attachment *at,
  58                             player_pose pose, m4x3f transform );
  59
  60    void (* get_camera) ( player_interface *player, player_attachment *at,
  61                             camera *cam );
  62
  63    void (* attatch )   ( player_interface *player, player_attachment *at,
  64                             void *storage );
  65
  66    void (* reset )     ( player_interface *player, player_attachment *at,
  67                            struct respawn_point *spawn );
  68
  69    void (* store_state)( player_interface *player, player_attachment *at );
  70    void (* load_state) ( player_interface *player, player_attachment *at );
  71    void (* debug_ui)   ( player_interface *player, player_attachment *at );
  72    void (* gate_transport)( player_interface *player, player_attachment *at,
  73                             teleport_gate *gate );
  74 };
  75
  76 VG_STATIC void player_interface_create_player( player_interface *inst )
  77 {
  78    static int only_once = 0;
  79    assert( only_once == 0 );
  80    only_once ++;
  81
  82    inst->input_js1h = vg_create_named_input( "steer-h", k_input_type_axis );
  83    inst->input_js1v = vg_create_named_input( "steer-v", k_input_type_axis );
  84    inst->input_grab = vg_create_named_input( "grab",    k_input_type_axis_norm);
  85    inst->input_js2h = vg_create_named_input( "grab-h",  k_input_type_axis );
  86    inst->input_js2v = vg_create_named_input( "grab-v",  k_input_type_axis );
  87    inst->input_jump = vg_create_named_input( "jump",    k_input_type_button );
  88    inst->input_push = vg_create_named_input( "push",    k_input_type_button );
  89    inst->input_walk = vg_create_named_input( "walk",    k_input_type_button );
  90    inst->input_walkh= vg_create_named_input( "walk-h",  k_input_type_axis );
  91    inst->input_walkv= vg_create_named_input( "walk-v",  k_input_type_axis );
  92    inst->input_use  = vg_create_named_input( "use",     k_input_type_button );
  93    inst->input_reset= vg_create_named_input( "reset",   k_input_type_button );
  94
  95    const char *default_cfg[] =
  96    {
  97       "bind  steer-h gp-ls-h",
  98       "bind -steer-h a",
  99       "bind +steer-h d",
 100
 101       "bind  steer-v gp-ls-v",
 102       "bind -steer-v w",
 103       "bind +steer-v s",
 104
 105       "bind  grab gp-rt",
 106       "bind +grab shift",
 107       "bind  grab-h gp-rs-h",
 108       "bind  grab-v gp-rs-v",
 109
 110       "bind jump space",
 111       "bind jump gp-a",
 112
 113       "bind push gp-b",
 114       "bind push w",
 115
 116       "bind walk shift",
 117       "bind walk gp-ls",
 118
 119       "bind  walk-h  gp-ls-h",
 120       "bind  walk-v -gp-ls-v",
 121       "bind +walk-h d",
 122       "bind -walk-h a",
 123       "bind +walk-v w",
 124       "bind -walk-v s",
 125
 126       "bind reset gp-lb",
 127       "bind reset r",
 128
 129       "bind use gp-y",
 130       "bind use e",
 131    };
 132
 133    for( int i=0; i<vg_list_size(default_cfg); i++ )
 134       vg_execute_console_input(default_cfg[i]);
 135
 136    v3_zero( inst->rb.co );
 137    v3_zero( inst->rb.w );
 138    v3_zero( inst->rb.v );
 139    q_identity( inst->rb.q );
 140    m4x3_identity( inst->rb.to_world );
 141    m4x3_identity( inst->rb.to_local );
 142 }
 143
 144 VG_STATIC void player_use_avatar( player_interface *player,
 145                                   struct player_avatar *av )
 146 {
 147    player->playeravatar = av;
 148    player_setup_ragdoll_from_avatar( &player->ragdoll, av );
 149 }
 150
 151 VG_STATIC void player_use_mesh( player_interface *player, glmesh *mesh )
 152 {
 153    player->playermesh = mesh;
 154 }
 155
 156 VG_STATIC void player_use_device( player_interface *player, player_device *dev,
 157                                   void *storage )
 158 {
 159    player->dev.device = dev;
 160    player->dev.storage = storage;
 161
 162    player->dev.device->bind( player, &player->dev );
 163 }
 164
 165 VG_STATIC void player_pre_update( player_interface *player )
 166 {
 167    assert( player->dev.device );
 168
 169    v3_copy( player->rb.co, player->prev_position );
 170
 171    if( player->dev.device->pre_update )
 172       player->dev.device->pre_update( player, &player->dev );
 173 }
 174
 175 VG_STATIC void player_update( player_interface *player )
 176 {
 177    assert( player->dev.device );
 178
 179    if( player->dev.device->update )
 180       player->dev.device->update( player, &player->dev );
 181 }
 182
 183 VG_STATIC void player_apply_transport_to_cam( m4x3f transport )
 184 {
 185    /* FIXME: Applies to main_camera directly! */
 186
 187    /* Pre-emptively edit the camera matrices so that the motion vectors
 188     * are correct */
 189    m4x3f transport_i;
 190    m4x4f transport_4;
 191    m4x3_invert_affine( transport, transport_i );
 192    m4x3_expand( transport_i, transport_4 );
 193    m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
 194    m4x4_mul( main_camera.mtx.v,  transport_4, main_camera.mtx.v );
 195 }
 196
 197 VG_STATIC void player_post_update( player_interface *player )
 198 {
 199    /* FIXME: Applies to main_camera directly! */
 200
 201    assert( player->dev.device );
 202
 203    if( player->dev.device->post_update )
 204       player->dev.device->post_update( player, &player->dev );
 205
 206    /* FIXME: only need to test against the visible gate....
 207     *        OR... bvh */
 208
 209    for( int i=0; i<world.gate_count; i++ )
 210    {
 211       struct route_gate *rg = &world.gates[i];
 212       teleport_gate *gate = &rg->gate;
 213
 214       if( gate_intersect( gate, player->rb.co, player->prev_position ) )
 215       {
 216          player->dev.device->gate_transport( player, &player->dev, gate );
 217          v3_copy( player->rb.co, player->prev_position );
 218       }
 219    }
 220
 221 #if 0
 222    camera_update_transform( &player->cam );
 223    camera_update_view( &player->cam );
 224    camera_update_projection( &player->cam );
 225    camera_finalize( &player->cam );
 226 #endif
 227 }
 228
 229 #if 0
 230 VG_STATIC void player_pre_render( player_interface *player )
 231 {
 232    assert( player->dev.device );
 233
 234    if( player->dev.device->pre_render )
 235       player->dev.device->pre_render( player );
 236 }
 237 #endif
 238
 239 VG_STATIC void player_pre_render( player_interface *player )
 240 {
 241    player_pose pose;
 242    m4x3f transform;
 243
 244    player->dev.device->pose( player, &player->dev, pose, transform );
 245
 246    struct skeleton *sk = &player->playeravatar->sk;
 247
 248    skeleton_apply_pose( sk, pose, k_anim_apply_defer_ik );
 249    skeleton_apply_ik_pass( sk );
 250    skeleton_apply_pose( sk, pose, k_anim_apply_deffered_only );
 251    skeleton_apply_inverses( sk );
 252    skeleton_apply_transform( sk, transform );
 253    skeleton_debug( sk );
 254
 255    player->dev.device->get_camera( player, &player->dev, &player->cam );
 256    /* TODO: if dead copy ragdoll.. . */
 257 }
 258
 259 VG_STATIC void player_render( camera *cam, player_interface *player )
 260 {
 261    shader_viewchar_use();
 262    vg_tex2d_bind( &tex_characters, 0 );
 263    shader_viewchar_uTexMain( 0 );
 264    shader_viewchar_uCamera( cam->transform[3] );
 265    shader_viewchar_uPv( cam->mtx.pv );
 266    shader_link_standard_ub( _shader_viewchar.id, 2 );
 267    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
 268                          player->playeravatar->sk.bone_count,
 269                          0,
 270                          (float *)player->playeravatar->sk.final_mtx );
 271
 272    mesh_bind( player->playermesh );
 273    mesh_draw( player->playermesh );
 274 }
 275
 276 VG_STATIC void player_debugtext( int size, const char *fmt, ... )
 277 {
 278         char buffer[ 1024 ];
 279
 280    va_list args;
 281    va_start( args, fmt );
 282    vsnprintf( buffer, 1024, fmt, args );
 283    va_end( args );
 284
 285    ui_text( vg_uictx.cursor, buffer, size, k_text_align_right );
 286         vg_uictx.cursor[1] += 14*size;
 287 }
 288
 289 VG_STATIC void player_ui( player_interface *player )
 290 {
 291    /* TODO: if debugger enabled */
 292
 293    if( player->dev.device->debug_ui )
 294    {
 295       vg_uictx.cursor[0] = vg.window_x - 200;
 296       vg_uictx.cursor[1] = 0;
 297       vg_uictx.cursor[2] = 200;
 298       vg_uictx.cursor[3] = 200;
 299
 300       struct ui_vert *b = ui_fill_rect( vg_uictx.cursor, 0x70000000 );
 301
 302       vg_uictx.cursor[0] = vg.window_x;
 303       player->dev.device->debug_ui( player, &player->dev );
 304
 305       b[2].co[1] = vg_uictx.cursor[1];
 306       b[3].co[1] = vg_uictx.cursor[1];
 307    }
 308 }
 309
 310 VG_STATIC void player_spawn( player_interface *player,
 311                              struct respawn_point *rp )
 312 {
 313    v3_copy( rp->co, player->rb.co );
 314    v3_copy( rp->co, player->prev_position );
 315    v3_zero( player->rb.v );
 316    v3_zero( player->rb.w );
 317    q_identity( player->rb.q );
 318    rb_update_transform( &player->rb );
 319
 320    if( player->dev.device->reset )
 321       player->dev.device->reset( player, &player->dev, rp );
 322 }
 323
 324 /*
 325  * Apply per render-frame mouse look from player to angles
 326  */
 327 VG_STATIC void player_look( player_interface *player, v3f angles )
 328 {
 329    angles[2] = 0.0f;
 330    v2_muladds( angles, vg.mouse_delta, 0.0025f, angles );
 331
 332    if( vg_input.controller_should_use_trackpad_look )
 333    {
 334       static v2f last_input;
 335       static v2f vel;
 336       static v2f vel_smooth;
 337
 338       v2f input = { player->input_js2h->axis.value,
 339                     player->input_js2v->axis.value };
 340
 341       if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) )
 342       {
 343          v2_sub( input, last_input, vel );
 344          v2_muls( vel, 1.0f/vg.time_delta, vel );
 345       }
 346       else
 347       {
 348          v2_zero( vel );
 349       }
 350
 351       v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
 352
 353       v2_muladds( angles, vel_smooth, vg.time_delta, angles );
 354       v2_copy( input, last_input );
 355    }
 356    else
 357    {
 358       angles[0] += player->input_js2h->axis.value * vg.time_delta * 4.0f;
 359       angles[1] += player->input_js2v->axis.value * vg.time_delta * 4.0f;
 360    }
 361
 362    angles[1] = vg_clampf( angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
 363 }
 364
 365 #endif /* PLAYER_INTERFACE_H */