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
  10 static f32 k_glide_steer = 2.0f,
  11            k_glide_cl = 0.04f,
  12            k_glide_cs = 0.02f,
  13            k_glide_drag = 0.0001f,
  14            k_glide_slip_yaw = 0.1f,
  15            k_glide_lift_pitch = 0.0f,
  16            k_glide_wing_orient = -0.1f,
  17            k_glide_balance = 1.0f;
  18
  19 static i32 k_glide_pause = 0;
  20
  21 static void player_glide_pre_update(void){
  22 }
  23
  24 static void massless_accel( rigidbody *rb, v3f delta, v3f impulse ){
  25    /* linear */
  26    v3_muladds( rb->v, impulse, k_rb_delta, rb->v );
  27
  28    /* Angular velocity */
  29    v3f wa;
  30    v3_cross( delta, impulse, wa );
  31    v3_muladds( rb->w, wa, k_rb_delta, rb->w );
  32 }
  33
  34 static void calculate_lift( v3f vl, f32 aoa_bias,
  35                             v3f axis, v3f back, f32 power,
  36                             v3f out_force ){
  37    v3f up;
  38    v3_cross( back, axis, up );
  39
  40    v3f wind;
  41    v3_muladds( vl, axis, -v3_dot(axis,vl), wind );
  42
  43    f32 windv2 = v3_length2(wind),
  44        aoa    = atan2f( v3_dot( up, wind ), v3_dot( back, wind ) ) + aoa_bias,
  45        cl     = aoa / VG_PIf, /* TODO: make it a curve */
  46        L      = windv2 * cl * power;
  47
  48    v3f lift_dir;
  49    v3_normalize( wind );
  50    v3_cross( wind, axis, lift_dir );
  51
  52    /* this is where induced drag (from the flappy things) would go */
  53
  54    v3_muls( lift_dir, L, out_force );
  55 }
  56
  57 static void calculate_drag( v3f vl, f32 cd, v3f out_force ){
  58    f32 v2 = v3_length2( vl );
  59    v3f dir;
  60    v3_copy( vl, dir );
  61    v3_normalize( dir );
  62    v3_muls( vl, -cd*v2, out_force );
  63 }
  64
  65 static void player_glide_update(void){
  66    rigidbody *rb = &player_glide.rb;
  67
  68    v2f steer;
  69    joystick_state( k_srjoystick_steer, steer );
  70
  71    /* lift */
  72    v3f vl, wl;
  73    m3x3_mulv( rb->to_local, rb->v, vl );
  74    m3x3_mulv( rb->to_local, rb->w, wl );
  75
  76    v3f F, Flift, Fslip, Fdrag, FslipW, FliftW;
  77
  78    calculate_lift( vl, steer[1]*k_glide_steer,
  79                   (v3f){1,0,0},
  80                   (v3f){0,sinf(k_glide_wing_orient),cosf(k_glide_wing_orient)},
  81                   k_glide_cl, Flift );
  82    v3_copy( Flift, player_glide.info_lift );
  83    v3_cross( (v3f){0,0,0}, Flift, FliftW );
  84
  85    calculate_lift( vl, 0.0f,
  86                   (v3f){0,1,0},(v3f){0,0,1},
  87                   k_glide_cs, Fslip );
  88    v3_copy( Fslip, player_glide.info_slip );
  89    v3_cross( (v3f){0,k_glide_lift_pitch,k_glide_slip_yaw}, Fslip, FslipW );
  90
  91    calculate_drag( vl, k_glide_drag, Fdrag );
  92    v3_copy( Fdrag, player_glide.info_drag );
  93
  94    v3f balance = {0.0f,-k_glide_balance,0.0f};
  95    m3x3_mulv( rb->to_local, balance, balance );
  96
  97    v3f Fw = {
  98        steer[1]*k_glide_steer - balance[2],
  99        0.0f,
 100       -steer[0]*k_glide_steer + balance[0],
 101    };
 102
 103    if( player_glide.ticker ){
 104       player_glide.ticker --;
 105       return;
 106    }
 107    player_glide.ticker += k_glide_pause;
 108
 109    /* apply forces */
 110    v3_add( Flift, Fslip, F );
 111    v3_add( F, Fdrag, F );
 112
 113    m3x3_mulv( rb->to_world, F, F );
 114    v3_muladds( rb->v, F, k_rb_delta, rb->v );
 115
 116    v3_add( Fw, FslipW, Fw );
 117    v3_add( Fw, FliftW, Fw );
 118    m3x3_mulv( rb->to_world, Fw, Fw );
 119    v3_muladds( rb->w, Fw, k_rb_delta, rb->w );
 120
 121    /*
 122     * collisions & constraints
 123     */
 124    world_instance *world = world_current_instance();
 125    rb_solver_reset();
 126
 127    rigidbody _null = {0};
 128    _null.inv_mass = 0.0f;
 129    m3x3_zero( _null.iI );
 130    for( u32 i=0; i < vg_list_size(player_glide.parts); i ++ ){
 131       m4x3f mmdl;
 132       m4x3_mul( rb->to_world, player_glide.parts[i].mdl, mmdl );
 133
 134       if( player_glide.parts[i].shape == k_rb_shape_capsule ){
 135          vg_line_capsule( mmdl,
 136                           player_glide.parts[i].inf.r,
 137                           player_glide.parts[i].inf.h,
 138                           VG__BLACK );
 139       }
 140       else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
 141          vg_line_sphere( mmdl, player_glide.parts[i].r, 0 );
 142       }
 143
 144       if( rb_global_has_space() ){
 145          rb_ct *buf = rb_global_buffer();
 146
 147          u32 l = 0;
 148
 149          if( player_glide.parts[i].shape == k_rb_shape_capsule ){
 150             l = rb_capsule__scene( mmdl, &player_glide.parts[i].inf,
 151                                    NULL, world->geo_bh, buf,
 152                                    k_material_flag_ghosts );
 153          }
 154          else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
 155             l = rb_sphere__scene( mmdl, player_glide.parts[i].r,
 156                                   NULL, world->geo_bh, buf,
 157                                   k_material_flag_ghosts );
 158          }
 159
 160          for( u32 j=0; j<l; j ++ ){
 161             buf[j].rba = rb;
 162             buf[j].rbb = &_null;
 163          }
 164
 165          rb_contact_count += l;
 166       }
 167    }
 168
 169    rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
 170    for( u32 i=0; i<10; i ++ )
 171       rb_solve_contacts( rb_contact_buffer, rb_contact_count );
 172
 173    rb_iter( rb );
 174    rb_update_matrices( rb );
 175 }
 176
 177 static void player_glide_post_update(void){
 178    v3_copy( player_glide.rb.co, localplayer.rb.co );
 179    v4_copy( player_glide.rb.q, localplayer.rb.q );
 180    v3_copy( player_glide.rb.v, localplayer.rb.v );
 181    v3_copy( player_glide.rb.w, localplayer.rb.w );
 182    rb_update_matrices( &localplayer.rb );
 183 }
 184
 185 static void player_glide_animate(void){
 186    struct player_glide *g = &player_glide;
 187    struct player_glide_animator *animator = &g->animator;
 188    rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
 189 }
 190
 191 static void player_glide_pose( void *_animator, player_pose *pose ){
 192    struct skeleton *sk = &localplayer.skeleton;
 193    struct player_glide_animator *animator = _animator;
 194
 195    skeleton_sample_anim( sk, player_glide.anim_temp, 0.0f, pose->keyframes );
 196
 197    v3_copy( animator->root_co, pose->root_co );
 198    v4_copy( animator->root_q, pose->root_q );
 199 }
 200
 201 static void player_glide_post_animate(void){
 202    if( localplayer.cam_control.camera_mode == k_cam_firstperson )
 203       localplayer.cam_velocity_influence = 0.0f;
 204    else
 205       localplayer.cam_velocity_influence = 0.0f;
 206
 207    v3f fwd;
 208    v3_muls( localplayer.rb.to_world[2], -1.0f, fwd );
 209    v3_angles( fwd, localplayer.angles );
 210 }
 211
 212 static void player_glide_im_gui(void){
 213    player__debugtext( 1, "Nothing here" );
 214    player__debugtext( 1, " lift: %.2f %.2f %.2f",
 215                            player_glide.info_lift[0],
 216                            player_glide.info_lift[1],
 217                            player_glide.info_lift[2] );
 218    player__debugtext( 1, " slip: %.2f %.2f %.2f",
 219                            player_glide.info_slip[0],
 220                            player_glide.info_slip[1],
 221                            player_glide.info_slip[2] );
 222    player__debugtext( 1, " drag: %.2f %.2f %.2f",
 223                            player_glide.info_drag[0],
 224                            player_glide.info_drag[1],
 225                            player_glide.info_drag[2] );
 226 }
 227
 228 static void player_glide_bind(void){
 229    struct skeleton *sk = &localplayer.skeleton;
 230    player_glide.anim_temp = skeleton_get_anim( sk, "idle_cycle+y" );
 231
 232    u32 mask = VG_VAR_CHEAT|VG_VAR_PERSISTENT;
 233    VG_VAR_F32( k_glide_steer, flags=mask );
 234    VG_VAR_F32( k_glide_cl, flags=mask );
 235    VG_VAR_F32( k_glide_cs, flags=mask );
 236    VG_VAR_F32( k_glide_drag, flags=mask );
 237    VG_VAR_F32( k_glide_slip_yaw, flags=mask );
 238    VG_VAR_F32( k_glide_lift_pitch, flags=mask );
 239    VG_VAR_I32( k_glide_pause, flags=mask );
 240    VG_VAR_F32( k_glide_balance, flags=mask );
 241    VG_VAR_F32( k_glide_wing_orient, flags=mask );
 242
 243    f32 mass = 0.0f,
 244        k_density = 8.0f,
 245        k_inertia_scale = 1.0f;
 246    m3x3f I;
 247    m3x3_zero( I );
 248
 249    for( u32 i=0; i<vg_list_size(player_glide.parts); i ++ ){
 250       /* create part transform matrix */
 251       v4f qp, qy, qr, q;
 252       q_axis_angle( qp, (v3f){1,0,0}, player_glide.parts[i].euler[0] );
 253       q_axis_angle( qy, (v3f){0,1,0}, player_glide.parts[i].euler[1] );
 254       q_axis_angle( qr, (v3f){0,0,1}, player_glide.parts[i].euler[2] );
 255
 256       q_mul( qr, qy, q );
 257       q_mul( q, qp, q );
 258
 259       q_m3x3( q, player_glide.parts[i].mdl );
 260       v3_copy( player_glide.parts[i].co, player_glide.parts[i].mdl[3] );
 261
 262       /* add it to inertia model */
 263
 264       if( player_glide.parts[i].shape == k_rb_shape_capsule ){
 265          f32 r  = player_glide.parts[i].inf.r,
 266              h  = player_glide.parts[i].inf.h,
 267              pv = vg_capsule_volume( r, h ),
 268              pm = pv * k_density;
 269
 270          mass += pm;
 271
 272          m3x3f pI;
 273          vg_capsule_inertia( r, h, pm, pI );
 274          vg_rotate_inertia( pI, player_glide.parts[i].mdl );
 275          vg_translate_inertia( pI, pm, player_glide.parts[i].co );
 276          m3x3_add( I, pI, I );
 277       }
 278       else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
 279          f32 r  = player_glide.parts[i].r,
 280              pv = vg_sphere_volume( r ),
 281              pm = pv * k_density;
 282
 283          mass += pm;
 284          m3x3f pI;
 285          vg_sphere_inertia( r, pm, pI );
 286          vg_translate_inertia( pI, pm, player_glide.parts[i].co );
 287          m3x3_add( I, pI, I );
 288       }
 289    }
 290
 291    /* set inverses */
 292    m3x3_inv( I, player_glide.rb.iI );
 293    player_glide.rb.inv_mass = 1.0f / mass;
 294 }
 295
 296 #endif /* PLAYER_GLIDE_C */