player_glide.c

   1 #ifndef PLAYER_GLIDE_C
   2 #define PLAYER_GLIDE_C
   3
   4 #include "player_glide.h"
   5 #include "input.h"
   6
   7 #include "vg/vg_rigidbody.h"
   8 #include "scene_rigidbody.h"
   9 #include "shaders/model_board_view.h"
  10
  11 static f32 k_glide_steer = 2.0f,
  12            k_glide_cl = 0.04f,
  13            k_glide_cs = 0.02f,
  14            k_glide_drag = 0.0001f,
  15            k_glide_slip_yaw = 0.1f,
  16            k_glide_lift_pitch = 0.0f,
  17            k_glide_wing_orient = -0.1f,
  18            k_glide_balance = 1.0f;
  19
  20 static i32 k_glide_pause = 0;
  21
  22 static void player_glide_pre_update(void){
  23    if( button_down(k_srbind_use) ){
  24       localplayer.subsystem = k_player_subsystem_skate;
  25       localplayer.glider_orphan = 1;
  26
  27       player_skate.state.activity = k_skate_activity_air;
  28       player_skate.state.activity_prev = k_skate_activity_air;
  29
  30       q_mulv( localplayer.rb.q, (v3f){0.0f,1.0f,0.0f}, player_skate.state.cog );
  31       v3_add( player_skate.state.cog, localplayer.rb.co,
  32               player_skate.state.cog );
  33       v3_copy( localplayer.rb.v, player_skate.state.cog_v );
  34
  35       player__begin_holdout( (v3f){0.0f,0.0f,0.0f} );
  36       player__skate_reset_animator();
  37       player__skate_clear_mechanics();
  38       v3_copy( (v3f){0.0f,0.0f,0.0f}, player_skate.state.trick_euler );
  39
  40       player__approximate_best_trajectory();
  41    }
  42 }
  43
  44 static void massless_accel( rigidbody *rb, v3f delta, v3f impulse ){
  45    /* linear */
  46    v3_muladds( rb->v, impulse, k_rb_delta, rb->v );
  47
  48    /* Angular velocity */
  49    v3f wa;
  50    v3_cross( delta, impulse, wa );
  51    v3_muladds( rb->w, wa, k_rb_delta, rb->w );
  52 }
  53
  54 static void calculate_lift( v3f vl, f32 aoa_bias,
  55                             v3f axis, v3f back, f32 power,
  56                             v3f out_force ){
  57    v3f up;
  58    v3_cross( back, axis, up );
  59
  60    v3f wind;
  61    v3_muladds( vl, axis, -v3_dot(axis,vl), wind );
  62
  63    f32 windv2 = v3_length2(wind),
  64        aoa    = atan2f( v3_dot( up, wind ), v3_dot( back, wind ) ) + aoa_bias,
  65        cl     = aoa / VG_PIf, /* TODO: make it a curve */
  66        L      = windv2 * cl * power;
  67
  68    v3f lift_dir;
  69    v3_normalize( wind );
  70    v3_cross( wind, axis, lift_dir );
  71
  72    /* this is where induced drag (from the flappy things) would go */
  73
  74    v3_muls( lift_dir, L, out_force );
  75 }
  76
  77 static void calculate_drag( v3f vl, f32 cd, v3f out_force ){
  78    f32 v2 = v3_length2( vl );
  79    v3f dir;
  80    v3_copy( vl, dir );
  81    v3_normalize( dir );
  82    v3_muls( vl, -cd*v2, out_force );
  83 }
  84
  85 /*
  86  * Returns true if the bottom sphere is hit
  87  */
  88 static bool glider_physics( v2f steer ){
  89    rigidbody *rb = &player_glide.rb;
  90
  91    /* lift */
  92    v3f vl, wl;
  93    m3x3_mulv( rb->to_local, rb->v, vl );
  94    m3x3_mulv( rb->to_local, rb->w, wl );
  95
  96    v3f F, Flift, Fslip, Fdrag, FslipW, FliftW;
  97
  98    calculate_lift( vl, steer[1]*k_glide_steer,
  99                   (v3f){1,0,0},
 100                   (v3f){0,sinf(k_glide_wing_orient),cosf(k_glide_wing_orient)},
 101                   k_glide_cl, Flift );
 102    v3_copy( Flift, player_glide.info_lift );
 103    v3_cross( (v3f){0,0,0}, Flift, FliftW );
 104
 105    calculate_lift( vl, 0.0f,
 106                   (v3f){0,1,0},(v3f){0,0,1},
 107                   k_glide_cs, Fslip );
 108    v3_copy( Fslip, player_glide.info_slip );
 109    v3_cross( (v3f){0,k_glide_lift_pitch,k_glide_slip_yaw}, Fslip, FslipW );
 110
 111    calculate_drag( vl, k_glide_drag, Fdrag );
 112    v3_copy( Fdrag, player_glide.info_drag );
 113
 114    v3f balance = {0.0f,-k_glide_balance,0.0f};
 115    m3x3_mulv( rb->to_local, balance, balance );
 116
 117    v3f Fw = {
 118        steer[1]*k_glide_steer - balance[2],
 119        0.0f,
 120       -steer[0]*k_glide_steer + balance[0],
 121    };
 122
 123    if( player_glide.ticker ){
 124       player_glide.ticker --;
 125       return 0;
 126    }
 127    player_glide.ticker += k_glide_pause;
 128
 129    /* apply forces */
 130    v3_add( Flift, Fslip, F );
 131    v3_add( F, Fdrag, F );
 132
 133    m3x3_mulv( rb->to_world, F, F );
 134    v3_muladds( rb->v, F, k_rb_delta, rb->v );
 135
 136    v3_add( Fw, FslipW, Fw );
 137    v3_add( Fw, FliftW, Fw );
 138    m3x3_mulv( rb->to_world, Fw, Fw );
 139    v3_muladds( rb->w, Fw, k_rb_delta, rb->w );
 140
 141
 142    /*
 143     * collisions & constraints
 144     */
 145    world_instance *world = world_current_instance();
 146    rb_solver_reset();
 147
 148    bool bottom_hit = 0;
 149
 150    rigidbody _null = {0};
 151    _null.inv_mass = 0.0f;
 152    m3x3_zero( _null.iI );
 153    for( u32 i=0; i < vg_list_size(player_glide.parts); i ++ ){
 154       m4x3f mmdl;
 155       m4x3_mul( rb->to_world, player_glide.parts[i].mdl, mmdl );
 156
 157       if( player_glide.parts[i].shape == k_rb_shape_capsule ){
 158          vg_line_capsule( mmdl,
 159                           player_glide.parts[i].inf.r,
 160                           player_glide.parts[i].inf.h,
 161                           VG__BLACK );
 162       }
 163       else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
 164          vg_line_sphere( mmdl, player_glide.parts[i].r, 0 );
 165       }
 166
 167       if( rb_global_has_space() ){
 168          rb_ct *buf = rb_global_buffer();
 169
 170          u32 l = 0;
 171
 172          if( player_glide.parts[i].shape == k_rb_shape_capsule ){
 173             l = rb_capsule__scene( mmdl, &player_glide.parts[i].inf,
 174                                    NULL, world->geo_bh, buf,
 175                                    k_material_flag_ghosts );
 176          }
 177          else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
 178             l = rb_sphere__scene( mmdl, player_glide.parts[i].r,
 179                                   NULL, world->geo_bh, buf,
 180                                   k_material_flag_ghosts );
 181          }
 182
 183          if( player_glide.parts[i].is_damage && l ){
 184             bottom_hit = 1;
 185          }
 186
 187          for( u32 j=0; j<l; j ++ ){
 188             buf[j].rba = rb;
 189             buf[j].rbb = &_null;
 190          }
 191
 192          rb_contact_count += l;
 193       }
 194    }
 195
 196    rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
 197    for( u32 i=0; i<10; i ++ )
 198       rb_solve_contacts( rb_contact_buffer, rb_contact_count );
 199
 200    rb_iter( rb );
 201    rb_update_matrices( rb );
 202
 203    return bottom_hit;
 204 }
 205
 206 static void player_glide_update(void){
 207    v2f steer;
 208    joystick_state( k_srjoystick_steer, steer );
 209
 210    if( glider_physics( steer ) ){
 211       vg_info( "player fell off due to glider hitting ground\n" );
 212       player__dead_transition( k_player_die_type_generic );
 213       localplayer.glider_orphan = 1;
 214    }
 215 }
 216
 217 static void player_glide_post_update(void){
 218    v3_copy( player_glide.rb.co, localplayer.rb.co );
 219    v4_copy( player_glide.rb.q, localplayer.rb.q );
 220    v3_copy( player_glide.rb.v, localplayer.rb.v );
 221    v3_copy( player_glide.rb.w, localplayer.rb.w );
 222    rb_update_matrices( &localplayer.rb );
 223 }
 224
 225 static void player_glide_animate(void){
 226    struct player_glide *g = &player_glide;
 227    struct player_glide_animator *animator = &g->animator;
 228    rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
 229 }
 230
 231 static void player_glide_pose( void *_animator, player_pose *pose ){
 232    struct skeleton *sk = &localplayer.skeleton;
 233    struct player_glide_animator *animator = _animator;
 234    pose->type = k_player_pose_type_ik;
 235    pose->board.lean = 0.0f;
 236
 237    skeleton_sample_anim( sk, player_glide.anim_glide, 0.0f, pose->keyframes );
 238
 239    v3f temp;
 240    q_mulv( animator->root_q, (v3f){0,-0.5f,0}, temp );
 241    v3_add( animator->root_co, temp, pose->root_co );
 242
 243    v4_copy( animator->root_q, pose->root_q );
 244 }
 245
 246 static void player_glide_post_animate(void){
 247    if( localplayer.cam_control.camera_mode == k_cam_firstperson )
 248       localplayer.cam_velocity_influence = 0.0f;
 249    else
 250       localplayer.cam_velocity_influence = 0.0f;
 251
 252    v3f fwd;
 253    v3_muls( localplayer.rb.to_world[2], -1.0f, fwd );
 254    v3_angles( fwd, localplayer.angles );
 255
 256    localplayer.cam_dist = 2.0f + v3_length( localplayer.rb.v )*0.2f;
 257 }
 258
 259 static void player_glide_animator_exchange( bitpack_ctx *ctx, void *data ){
 260    struct player_glide_animator *animator = data;
 261
 262    bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
 263    bitpack_qquat( ctx, animator->root_q );
 264 }
 265
 266 static void player_glide_im_gui(void){
 267    player__debugtext( 1, "Nothing here" );
 268    player__debugtext( 1, " lift: %.2f %.2f %.2f",
 269                            player_glide.info_lift[0],
 270                            player_glide.info_lift[1],
 271                            player_glide.info_lift[2] );
 272    player__debugtext( 1, " slip: %.2f %.2f %.2f",
 273                            player_glide.info_slip[0],
 274                            player_glide.info_slip[1],
 275                            player_glide.info_slip[2] );
 276    player__debugtext( 1, " drag: %.2f %.2f %.2f",
 277                            player_glide.info_drag[0],
 278                            player_glide.info_drag[1],
 279                            player_glide.info_drag[2] );
 280 }
 281
 282 static int ccmd_player_glider_spawn( int argc, const char *argv[] ){
 283    localplayer.have_glider = 1;
 284    localplayer.glider_orphan = 0;
 285    player_glide.t = -1.0f;
 286    return 0;
 287 }
 288
 289 static void player_glide_bind(void){
 290
 291    u32 mask = VG_VAR_CHEAT|VG_VAR_PERSISTENT;
 292    VG_VAR_F32( k_glide_steer, flags=mask );
 293    VG_VAR_F32( k_glide_cl, flags=mask );
 294    VG_VAR_F32( k_glide_cs, flags=mask );
 295    VG_VAR_F32( k_glide_drag, flags=mask );
 296    VG_VAR_F32( k_glide_slip_yaw, flags=mask );
 297    VG_VAR_F32( k_glide_lift_pitch, flags=mask );
 298    VG_VAR_I32( k_glide_pause, flags=mask );
 299    VG_VAR_F32( k_glide_balance, flags=mask );
 300    VG_VAR_F32( k_glide_wing_orient, flags=mask );
 301
 302    vg_console_reg_cmd( "spawn_glider", ccmd_player_glider_spawn, NULL );
 303
 304    f32 mass = 0.0f,
 305        k_density = 8.0f,
 306        k_inertia_scale = 1.0f;
 307    m3x3f I;
 308    m3x3_zero( I );
 309
 310    for( u32 i=0; i<vg_list_size(player_glide.parts); i ++ ){
 311       /* create part transform matrix */
 312       v4f qp, qy, qr, q;
 313       q_axis_angle( qp, (v3f){1,0,0}, player_glide.parts[i].euler[0] );
 314       q_axis_angle( qy, (v3f){0,1,0}, player_glide.parts[i].euler[1] );
 315       q_axis_angle( qr, (v3f){0,0,1}, player_glide.parts[i].euler[2] );
 316
 317       q_mul( qr, qy, q );
 318       q_mul( q, qp, q );
 319
 320       q_m3x3( q, player_glide.parts[i].mdl );
 321       v3_copy( player_glide.parts[i].co, player_glide.parts[i].mdl[3] );
 322
 323       /* add it to inertia model */
 324
 325       if( player_glide.parts[i].shape == k_rb_shape_capsule ){
 326          f32 r  = player_glide.parts[i].inf.r,
 327              h  = player_glide.parts[i].inf.h,
 328              pv = vg_capsule_volume( r, h ),
 329              pm = pv * k_density;
 330
 331          mass += pm;
 332
 333          m3x3f pI;
 334          vg_capsule_inertia( r, h, pm, pI );
 335          vg_rotate_inertia( pI, player_glide.parts[i].mdl );
 336          vg_translate_inertia( pI, pm, player_glide.parts[i].co );
 337          m3x3_add( I, pI, I );
 338       }
 339       else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
 340          f32 r  = player_glide.parts[i].r,
 341              pv = vg_sphere_volume( r ),
 342              pm = pv * k_density;
 343
 344          mass += pm;
 345          m3x3f pI;
 346          vg_sphere_inertia( r, pm, pI );
 347          vg_translate_inertia( pI, pm, player_glide.parts[i].co );
 348          m3x3_add( I, pI, I );
 349       }
 350    }
 351
 352    /* set inverses */
 353    m3x3_inv( I, player_glide.rb.iI );
 354    player_glide.rb.inv_mass = 1.0f / mass;
 355
 356    /* resources */
 357    struct skeleton *sk = &localplayer.skeleton;
 358    player_glide.anim_glide = skeleton_get_anim( sk, "glide_pose" );
 359
 360    void *alloc = vg_mem.rtmemory;
 361    mdl_context *mdl = &player_glide.glider;
 362
 363    mdl_open( mdl, "models/glider.mdl", alloc );
 364    mdl_load_metadata_block( mdl, alloc );
 365
 366    vg_linear_clear( vg_mem.scratch );
 367
 368    u32 count = mdl_arrcount( &mdl->textures );
 369    player_glide.glider_textures =
 370       vg_linear_alloc(alloc,vg_align8(sizeof(GLuint)*(count+1)));
 371    player_glide.glider_textures[0] = vg.tex_missing;
 372
 373    mdl_async_load_glmesh( mdl, &player_glide.glider_mesh, NULL );
 374
 375    for( u32 i=0; i<count; i ++ ){
 376       vg_linear_clear( vg_mem.scratch );
 377       player_glide.glider_textures[i+1] = vg.tex_missing;
 378
 379       mdl_texture *tex = mdl_arritm( &mdl->textures, i );
 380       void *data = vg_linear_alloc( vg_mem.scratch, tex->file.pack_size );
 381       mdl_fread_pack_file( mdl, &tex->file, data );
 382       vg_tex2d_load_qoi_async( data, tex->file.pack_size,
 383                                VG_TEX2D_LINEAR|VG_TEX2D_CLAMP,
 384                                &player_glide.glider_textures[i+1] );
 385    }
 386
 387    mdl_close( mdl );
 388 }
 389
 390 static void player_glide_transition(void){
 391    localplayer.subsystem = k_player_subsystem_glide;
 392    localplayer.have_glider = 0;
 393
 394    v3_copy( localplayer.rb.co, player_glide.rb.co );
 395
 396    f32 dir = v3_dot( localplayer.rb.v, localplayer.rb.to_world[2] );
 397
 398    if( dir > 0.0f ){
 399       v4f qyaw;
 400       q_axis_angle( qyaw, (v3f){0,1,0}, VG_TAUf*0.5f );
 401       q_mul( qyaw, localplayer.rb.q, player_glide.rb.q );
 402       q_normalize( player_glide.rb.q );
 403    }
 404    else
 405       v4_copy( localplayer.rb.q,  player_glide.rb.q );
 406
 407    v3_copy( localplayer.rb.v,  player_glide.rb.v );
 408    v3_copy( localplayer.rb.w,  player_glide.rb.w );
 409    rb_update_matrices( &player_glide.rb );
 410
 411    player__begin_holdout( (v3f){0,0,0} );
 412 }
 413
 414 /*
 415  * TODO: more flexible way to call
 416  *      - this depends on the current state, but we need to pass a struct in
 417  *        that can hold that information instead so we can save it into
 418  *        the replay
 419  */
 420 static void player_glide_render( camera *cam, world_instance *world,
 421                                  player_pose *pose ){
 422    if( !((localplayer.subsystem == k_player_subsystem_glide) ||
 423          (localplayer.observing_system == k_player_subsystem_glide) ||
 424           localplayer.have_glider ||
 425           localplayer.glider_orphan) )
 426       return;
 427
 428    shader_model_board_view_use();
 429    shader_model_board_view_uTexMain( 0 );
 430    shader_model_board_view_uCamera( cam->transform[3] );
 431    shader_model_board_view_uPv( cam->mtx.pv );
 432
 433    shader_model_board_view_uDepthCompare(1);
 434    depth_compare_bind(
 435       shader_model_board_view_uTexSceneDepth,
 436       shader_model_board_view_uInverseRatioDepth,
 437       shader_model_board_view_uInverseRatioMain,
 438       cam );
 439
 440    WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world, model_board_view );
 441
 442    mdl_keyframe kf_res;
 443    if( localplayer.glider_orphan ){
 444       rb_extrapolate( &player_glide.rb, kf_res.co, kf_res.q );
 445       v3_fill( kf_res.s, 1.0f );
 446
 447       v3f temp;
 448       q_mulv( kf_res.q, (v3f){0,-0.5f,0}, temp );
 449       v3_add( temp, kf_res.co, kf_res.co );
 450    }
 451    else {
 452       f32 target;
 453       if( localplayer.subsystem == k_player_subsystem_glide ) target = 1.0f;
 454       else target = 0.0f;
 455
 456       /* TODO: TEMP */
 457       if( skaterift.activity != k_skaterift_replay )
 458          vg_slewf( &player_glide.t, target, vg.time_frame_delta * 4.0f );
 459
 460       mdl_keyframe kf_backpack;
 461
 462       struct skeleton *sk = &localplayer.skeleton;
 463       m4x3_mulv( localplayer.final_mtx[localplayer.id_chest ],
 464             sk->bones[localplayer.id_chest].co,
 465             kf_backpack.co );
 466
 467       v4f qyaw, qpitch, qchest, q;
 468       q_axis_angle( qyaw,   (v3f){0,1,0}, VG_TAUf*0.25f );
 469       q_axis_angle( qpitch, (v3f){1,0,0}, VG_TAUf*0.25f );
 470       m3x3_q( localplayer.final_mtx[ localplayer.id_chest ], qchest );
 471
 472       q_mul( qyaw, qpitch, q );
 473       q_mul( qchest, q, kf_backpack.q );
 474       q_normalize( kf_backpack.q );
 475
 476       f32 scale;
 477       if( player_glide.t <= 0.0f ){
 478          f32 st  = player_glide.t + 1.0f,
 479              sst = vg_smoothstepf(st),
 480              isst= 1.0f - sst;
 481          scale = vg_lerpf( 0.0f, 0.2f, sst );
 482
 483          v4f qspin;
 484          q_axis_angle( qspin, (v3f){0,0,1}, VG_TAUf * isst * 0.5f );
 485          q_mul( kf_backpack.q, qspin, kf_backpack.q );
 486          kf_backpack.co[1] += isst * 1.0f;
 487          v3_muladds( kf_backpack.co,
 488                      localplayer.final_mtx[ localplayer.id_chest ][0],
 489                      isst * 0.25f,
 490                      kf_backpack.co );
 491       }
 492       else{
 493          scale = vg_lerpf( 0.2f, 1.0f, vg_smoothstepf(player_glide.t) );
 494       }
 495
 496
 497       v3_fill( kf_backpack.s, scale );
 498
 499       v3_copy( pose->root_co, kf_res.co );
 500       v4_copy( pose->root_q, kf_res.q );
 501       v3_fill( kf_res.s, scale );
 502
 503       f32 blend = vg_smoothstepf( vg_maxf( 0, player_glide.t ) );
 504       keyframe_lerp( &kf_backpack, &kf_res, blend, &kf_res );
 505    }
 506
 507    m4x3f mmdl;
 508    q_m3x3( kf_res.q, mmdl );
 509    m3x3_scale( mmdl, kf_res.s );
 510    v3_copy( kf_res.co, mmdl[3] );
 511
 512    u32 current_tex = 0xffffffff;
 513    glActiveTexture( GL_TEXTURE0 );
 514
 515    mdl_context *mdl = &player_glide.glider;
 516    mesh_bind( &player_glide.glider_mesh );
 517
 518    for( u32 i=0; i<mdl_arrcount(&mdl->meshs); i ++ ){
 519       mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );
 520
 521       m4x3f mmmdl;
 522       mdl_transform_m4x3( &mesh->transform, mmmdl );
 523       m4x3_mul( mmdl, mmmdl, mmmdl );
 524
 525       shader_model_board_view_uMdl( mmmdl );
 526
 527       for( u32 j=0; j<mesh->submesh_count; j ++ ){
 528          mdl_submesh *sm = mdl_arritm( &mdl->submeshs, mesh->submesh_start+j );
 529          if( !sm->material_id ) {
 530             vg_error( "Invalid material ID 0\n" );
 531             continue;
 532          }
 533
 534          mdl_material *mat = mdl_arritm( &mdl->materials, sm->material_id-1 );
 535          if( mat->tex_diffuse != current_tex ){
 536             glBindTexture( GL_TEXTURE_2D,
 537                   player_glide.glider_textures[ mat->tex_diffuse ] );
 538             current_tex = mat->tex_diffuse;
 539          }
 540
 541          mdl_draw_submesh( sm );
 542       }
 543    }
 544 }
 545
 546 #endif /* PLAYER_GLIDE_C */