build system revision

[carveJwlIkooP6JGAAIwe30JlM.git] / player_glide.c

#ifndef PLAYER_GLIDE_C
#define PLAYER_GLIDE_C

#include "player_glide.h"
#include "input.h"

#include "vg/vg_rigidbody.h"
#include "scene_rigidbody.h"
#include "shaders/model_board_view.h"
#include "shaders/model_entity.h"

static f32 k_glide_steer = 2.0f,
           k_glide_cl = 0.04f,
           k_glide_cs = 0.02f,
           k_glide_drag = 0.0001f,
           k_glide_slip_yaw = 0.1f,
           k_glide_lift_pitch = 0.0f,
           k_glide_wing_orient = -0.1f,
           k_glide_balance = 1.0f;

static i32 k_glide_pause = 0;

static void player_glide_pre_update(void){
   if( button_down(k_srbind_use) ){
      localplayer.subsystem = k_player_subsystem_skate;
      localplayer.glider_orphan = 1;

      player_skate.state.activity = k_skate_activity_air;
      player_skate.state.activity_prev = k_skate_activity_air;

      q_mulv( localplayer.rb.q, (v3f){0.0f,1.0f,0.0f}, player_skate.state.cog );
      v3_add( player_skate.state.cog, localplayer.rb.co, 
              player_skate.state.cog );
      v3_copy( localplayer.rb.v, player_skate.state.cog_v );

      player__begin_holdout( (v3f){0.0f,0.0f,0.0f} );
      player__skate_reset_animator();
      player__skate_clear_mechanics();
      v3_copy( (v3f){0.0f,0.0f,0.0f}, player_skate.state.trick_euler );

      player__approximate_best_trajectory();
   }
}

static void massless_accel( rigidbody *rb, v3f delta, v3f impulse ){
   /* linear */
   v3_muladds( rb->v, impulse, vg.time_fixed_delta, rb->v );
   
   /* Angular velocity */
   v3f wa;
   v3_cross( delta, impulse, wa );
   v3_muladds( rb->w, wa, vg.time_fixed_delta, rb->w );
}

static void calculate_lift( v3f vl, f32 aoa_bias, 
                            v3f axis, v3f back, f32 power,
                            v3f out_force ){
   v3f up;
   v3_cross( back, axis, up );

   v3f wind;
   v3_muladds( vl, axis, -v3_dot(axis,vl), wind );
   
   f32 windv2 = v3_length2(wind),
       aoa    = atan2f( v3_dot( up, wind ), v3_dot( back, wind ) ) + aoa_bias,
       cl     = aoa / VG_PIf, /* TODO: make it a curve */
       L      = windv2 * cl * power;

   v3f lift_dir;
   v3_normalize( wind );
   v3_cross( wind, axis, lift_dir );

   /* this is where induced drag (from the flappy things) would go */
   
   v3_muls( lift_dir, L, out_force );
}

static void calculate_drag( v3f vl, f32 cd, v3f out_force ){
   f32 v2 = v3_length2( vl );
   v3f dir;
   v3_copy( vl, dir );
   v3_normalize( dir );
   v3_muls( vl, -cd*v2, out_force );
}

/*
 * Returns true if the bottom sphere is hit 
 */
static bool glider_physics( v2f steer ){
   rigidbody *rb = &player_glide.rb;

   /* lift */
   v3f vl, wl;
   m3x3_mulv( rb->to_local, rb->v, vl );
   m3x3_mulv( rb->to_local, rb->w, wl );
   
   v3f F, Flift, Fslip, Fdrag, FslipW, FliftW;

   calculate_lift( vl, steer[1]*k_glide_steer, 
                  (v3f){1,0,0},
                  (v3f){0,sinf(k_glide_wing_orient),cosf(k_glide_wing_orient)},
                  k_glide_cl, Flift );
   v3_copy( Flift, player_glide.info_lift );
   v3_cross( (v3f){0,0,0}, Flift, FliftW );
   
   calculate_lift( vl, 0.0f,
                  (v3f){0,1,0},(v3f){0,0,1},
                  k_glide_cs, Fslip );
   v3_copy( Fslip, player_glide.info_slip );
   v3_cross( (v3f){0,k_glide_lift_pitch,k_glide_slip_yaw}, Fslip, FslipW );

   calculate_drag( vl, k_glide_drag, Fdrag );
   v3_copy( Fdrag, player_glide.info_drag );

   v3f balance = {0.0f,-k_glide_balance,0.0f};
   m3x3_mulv( rb->to_local, balance, balance );

   v3f Fw = {
       steer[1]*k_glide_steer - balance[2],
       0.0f,
      -steer[0]*k_glide_steer + balance[0],
   };

   if( player_glide.ticker ){
      player_glide.ticker --;
      return 0;
   }
   player_glide.ticker += k_glide_pause;

   /* apply forces */
   v3_add( Flift, Fslip, F );
   v3_add( F, Fdrag, F );

   m3x3_mulv( rb->to_world, F, F );
   v3_muladds( rb->v, F, vg.time_fixed_delta, rb->v );

   v3_add( Fw, FslipW, Fw );
   v3_add( Fw, FliftW, Fw );
   m3x3_mulv( rb->to_world, Fw, Fw );
   v3_muladds( rb->w, Fw, vg.time_fixed_delta, rb->w );


   /* 
    * collisions & constraints
    */
   world_instance *world = world_current_instance();
   rb_solver_reset();

   bool bottom_hit = 0;

   rigidbody _null = {0};
   _null.inv_mass = 0.0f;
   m3x3_zero( _null.iI );
   for( u32 i=0; i < vg_list_size(player_glide.parts); i ++ ){
      m4x3f mmdl;
      m4x3_mul( rb->to_world, player_glide.parts[i].mdl, mmdl );

      if( player_glide.parts[i].shape == k_rb_shape_capsule ){
         vg_line_capsule( mmdl,
                          player_glide.parts[i].inf.r,
                          player_glide.parts[i].inf.h,
                          VG__BLACK );
      }
      else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
         vg_line_sphere( mmdl, player_glide.parts[i].r, 0 );
      }

      if( rb_global_has_space() ){
         rb_ct *buf = rb_global_buffer();

         u32 l = 0;
         
         if( player_glide.parts[i].shape == k_rb_shape_capsule ){
            l = rb_capsule__scene( mmdl, &player_glide.parts[i].inf,
                                   NULL, world->geo_bh, buf, 
                                   k_material_flag_ghosts );
         }
         else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
            l = rb_sphere__scene( mmdl, player_glide.parts[i].r,
                                  NULL, world->geo_bh, buf,
                                  k_material_flag_ghosts );
         }

         if( player_glide.parts[i].is_damage && l ){
            bottom_hit = 1;
         }

         for( u32 j=0; j<l; j ++ ){
            buf[j].rba = rb;
            buf[j].rbb = &_null;
         }

         rb_contact_count += l;
      }
   }

   rb_presolve_contacts( rb_contact_buffer, 
                         vg.time_fixed_delta, rb_contact_count );
   for( u32 i=0; i<10; i ++ )
      rb_solve_contacts( rb_contact_buffer, rb_contact_count );
   
   rb_iter( rb );
   rb_update_matrices( rb );

   return bottom_hit;
}

static void player_glide_update(void){
   v2f steer;
   joystick_state( k_srjoystick_steer, steer );

   if( glider_physics( steer ) ){
      vg_info( "player fell off due to glider hitting ground\n" );
      player__dead_transition( k_player_die_type_generic );
      localplayer.glider_orphan = 1;
   }
}

static void player_glide_post_update(void){
   v3_copy( player_glide.rb.co, localplayer.rb.co );
   v4_copy( player_glide.rb.q, localplayer.rb.q );
   v3_copy( player_glide.rb.v, localplayer.rb.v );
   v3_copy( player_glide.rb.w, localplayer.rb.w );
   rb_update_matrices( &localplayer.rb );
}

static void player_glide_animate(void){
   struct player_glide *g = &player_glide;
   struct player_glide_animator *animator = &g->animator;
   rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
}

static void player_glide_pose( void *_animator, player_pose *pose ){
   struct skeleton *sk = &localplayer.skeleton;
   struct player_glide_animator *animator = _animator;
   pose->type = k_player_pose_type_ik;
   pose->board.lean = 0.0f;

   skeleton_sample_anim( sk, player_glide.anim_glide, 0.0f, pose->keyframes );

   v3f temp;
   q_mulv( animator->root_q, (v3f){0,-0.5f,0}, temp );
   v3_add( animator->root_co, temp, pose->root_co );

   v4_copy( animator->root_q, pose->root_q );
}

static void player_glide_post_animate(void){
   if( localplayer.cam_control.camera_mode == k_cam_firstperson )
      localplayer.cam_velocity_influence = 0.0f;
   else
      localplayer.cam_velocity_influence = 0.0f;

   v3f fwd;
   v3_muls( localplayer.rb.to_world[2], -1.0f, fwd );
   v3_angles( fwd, localplayer.angles );

   localplayer.cam_dist = 2.0f + v3_length( localplayer.rb.v )*0.2f;
}

static void player_glide_animator_exchange( bitpack_ctx *ctx, void *data ){
   struct player_glide_animator *animator = data;

   bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
   bitpack_qquat( ctx, animator->root_q );
}

static void 
player_glide_remote_animator_exchange( bitpack_ctx *ctx, void *data ){
   struct remote_glider_animator *animator = data;

   bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
   bitpack_qf32( ctx, 8, 0.0f, 1.0f, &animator->s );
   bitpack_qquat( ctx, animator->root_q );
}

static void player_glide_im_gui(void){
   player__debugtext( 1, "Nothing here" );
   player__debugtext( 1, " lift: %.2f %.2f %.2f", 
                           player_glide.info_lift[0],
                           player_glide.info_lift[1],
                           player_glide.info_lift[2] );
   player__debugtext( 1, " slip: %.2f %.2f %.2f", 
                           player_glide.info_slip[0],
                           player_glide.info_slip[1],
                           player_glide.info_slip[2] );
   player__debugtext( 1, " drag: %.2f %.2f %.2f", 
                           player_glide.info_drag[0],
                           player_glide.info_drag[1],
                           player_glide.info_drag[2] );
}

static void player_glide_equip_glider(void){
   if( !localplayer.have_glider ){
      localplayer.have_glider = 1;
      localplayer.glider_orphan = 0;
      player_glide.t = -1.0f;
   }
}

static int ccmd_player_glider_spawn( int argc, const char *argv[] ){
   if( vg_console.cheats ){
      player_glide_equip_glider();
   }
   else {
      vg_error( "Can't spawn without cheats enabled.\n" );
   }
   return 0;
}

static void player_glide_bind(void)
{
   u32 mask = VG_VAR_CHEAT|VG_VAR_PERSISTENT;
   VG_VAR_F32( k_glide_steer, flags=mask );
   VG_VAR_F32( k_glide_cl, flags=mask );
   VG_VAR_F32( k_glide_cs, flags=mask );
   VG_VAR_F32( k_glide_drag, flags=mask );
   VG_VAR_F32( k_glide_slip_yaw, flags=mask );
   VG_VAR_F32( k_glide_lift_pitch, flags=mask );
   VG_VAR_I32( k_glide_pause, flags=mask );
   VG_VAR_F32( k_glide_balance, flags=mask );
   VG_VAR_F32( k_glide_wing_orient, flags=mask );

   vg_console_reg_cmd( "spawn_glider", ccmd_player_glider_spawn, NULL );

   f32 mass = 0.0f,k_density = 8.0f;
   m3x3f I;
   m3x3_zero( I );

   for( u32 i=0; i<vg_list_size(player_glide.parts); i ++ ){
      /* create part transform matrix */
      v4f qp, qy, qr, q;
      q_axis_angle( qp, (v3f){1,0,0}, player_glide.parts[i].euler[0] );
      q_axis_angle( qy, (v3f){0,1,0}, player_glide.parts[i].euler[1] );
      q_axis_angle( qr, (v3f){0,0,1}, player_glide.parts[i].euler[2] );

      q_mul( qr, qy, q );
      q_mul( q, qp, q );

      q_m3x3( q, player_glide.parts[i].mdl );
      v3_copy( player_glide.parts[i].co, player_glide.parts[i].mdl[3] );

      /* add it to inertia model */

      if( player_glide.parts[i].shape == k_rb_shape_capsule ){
         f32 r  = player_glide.parts[i].inf.r,
             h  = player_glide.parts[i].inf.h,
             pv = vg_capsule_volume( r, h ),
             pm = pv * k_density;

         mass += pm;

         m3x3f pI;
         vg_capsule_inertia( r, h, pm, pI );
         vg_rotate_inertia( pI, player_glide.parts[i].mdl );
         vg_translate_inertia( pI, pm, player_glide.parts[i].co );
         m3x3_add( I, pI, I );
      }
      else if( player_glide.parts[i].shape == k_rb_shape_sphere ){
         f32 r  = player_glide.parts[i].r,
             pv = vg_sphere_volume( r ),
             pm = pv * k_density;

         mass += pm;
         m3x3f pI;
         vg_sphere_inertia( r, pm, pI );
         vg_translate_inertia( pI, pm, player_glide.parts[i].co );
         m3x3_add( I, pI, I );
      }
   }

   /* set inverses */
   m3x3_inv( I, player_glide.rb.iI );
   player_glide.rb.inv_mass = 1.0f / mass;

   /* resources */
   struct skeleton *sk = &localplayer.skeleton;
   player_glide.anim_glide = skeleton_get_anim( sk, "glide_pose" );

   void *alloc = vg_mem.rtmemory;
   mdl_context *mdl = &player_glide.glider;

   mdl_open( mdl, "models/glider.mdl", alloc );
   mdl_load_metadata_block( mdl, alloc );

   vg_linear_clear( vg_mem.scratch );

   u32 count = mdl_arrcount( &mdl->textures );
   player_glide.glider_textures = 
      vg_linear_alloc(alloc,vg_align8(sizeof(GLuint)*(count+1)));
   player_glide.glider_textures[0] = vg.tex_missing;

   mdl_async_load_glmesh( mdl, &player_glide.glider_mesh, NULL );

   for( u32 i=0; i<count; i ++ ){
      vg_linear_clear( vg_mem.scratch );
      player_glide.glider_textures[i+1] = vg.tex_missing;

      mdl_texture *tex = mdl_arritm( &mdl->textures, i );
      void *data = vg_linear_alloc( vg_mem.scratch, tex->file.pack_size );
      mdl_fread_pack_file( mdl, &tex->file, data );
      vg_tex2d_load_qoi_async( data, tex->file.pack_size, 
                               VG_TEX2D_LINEAR|VG_TEX2D_CLAMP,
                               &player_glide.glider_textures[i+1] );
   }

   /* load trail positions */
   mdl_array_ptr markers;
   MDL_LOAD_ARRAY( mdl, &markers, ent_marker, vg_mem.scratch );

   for( u32 i=0; i<mdl_arrcount( &markers ); i ++ ){
      ent_marker *marker = mdl_arritm( &markers, i );
      v3_copy( marker->transform.co, 
               player_glide.trail_positions[ player_glide.trail_count ++ ] );

      if( player_glide.trail_count == vg_list_size(trails_glider) )
         break;
   }

   mdl_close( mdl );

   /* allocate effects */
   for( u32 i=0; i<vg_list_size(trails_glider); i ++ ){
      trail_alloc( &trails_glider[i], 200 );
   }
}

static void player_glide_transition(void){
   localplayer.subsystem = k_player_subsystem_glide;
   localplayer.have_glider = 0;
   world_static.challenge_target = NULL;
   world_static.challenge_timer = 0.0f;
   world_static.focused_entity = 0;
   world_static.last_use = 0.0;
   for( u32 i=0; i<vg_list_size(world_static.instances); i++ ){
      world_instance *instance = &world_static.instances[i];
      if( instance->status == k_world_status_loaded ){
         world_routes_clear( instance );
      }
   }

   v3_copy( localplayer.rb.co, player_glide.rb.co );

   f32 dir = v3_dot( localplayer.rb.v, localplayer.rb.to_world[2] );

   if( dir > 0.0f ){
      v4f qyaw;
      q_axis_angle( qyaw, (v3f){0,1,0}, VG_TAUf*0.5f );
      q_mul( qyaw, localplayer.rb.q, player_glide.rb.q );
      q_normalize( player_glide.rb.q );
   }
   else 
      v4_copy( localplayer.rb.q,  player_glide.rb.q );

   v3_copy( localplayer.rb.v,  player_glide.rb.v );
   v3_copy( localplayer.rb.w,  player_glide.rb.w );
   rb_update_matrices( &player_glide.rb );

   player__begin_holdout( (v3f){0,0,0} );
}

static void render_glider_model( camera *cam, world_instance *world,
                                 m4x3f mmdl, enum board_shader shader ){
   u32 current_tex = 0xffffffff;
   glActiveTexture( GL_TEXTURE0 );

   mdl_context *mdl = &player_glide.glider;
   mesh_bind( &player_glide.glider_mesh );

   for( u32 i=0; i<mdl_arrcount(&mdl->meshs); i ++ ){
      mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );

      m4x3f mmmdl;
      mdl_transform_m4x3( &mesh->transform, mmmdl );
      m4x3_mul( mmdl, mmmdl, mmmdl );

      if( shader == k_board_shader_player )
         shader_model_board_view_uMdl( mmmdl );
      else if( shader == k_board_shader_entity ){
         m4x4f m4mmmdl;
         m4x3_expand( mmmdl, m4mmmdl );
         m4x4_mul( cam->mtx_prev.pv, m4mmmdl, m4mmmdl );

         shader_model_entity_uMdl( mmmdl );
         shader_model_entity_uPvmPrev( m4mmmdl );
      }

      for( u32 j=0; j<mesh->submesh_count; j ++ ){
         mdl_submesh *sm = mdl_arritm( &mdl->submeshs, mesh->submesh_start+j );
         if( !sm->material_id ) {
            vg_error( "Invalid material ID 0\n" );
            continue;
         }

         mdl_material *mat = mdl_arritm( &mdl->materials, sm->material_id-1 );
         if( mat->tex_diffuse != current_tex ){
            glBindTexture( GL_TEXTURE_2D, 
                  player_glide.glider_textures[ mat->tex_diffuse ] );
            current_tex = mat->tex_diffuse;
         }

         mdl_draw_submesh( sm );
      }
   }
}

/*
 * TODO: more flexible way to call
 *      - this depends on the current state, but we need to pass a struct in
 *        that can hold that information instead so we can save it into 
 *        the replay
 */
static void player_glide_render( camera *cam, world_instance *world,
                                 player_pose *pose ){
   if( !((localplayer.subsystem == k_player_subsystem_glide) ||
         (localplayer.observing_system == k_player_subsystem_glide) ||
          localplayer.have_glider ||
          localplayer.glider_orphan) )
      return;

   shader_model_board_view_use();
   shader_model_board_view_uTexMain( 0 );
   shader_model_board_view_uCamera( cam->transform[3] );
   shader_model_board_view_uPv( cam->mtx.pv );

   shader_model_board_view_uDepthCompare(1);
   depth_compare_bind(
      shader_model_board_view_uTexSceneDepth,
      shader_model_board_view_uInverseRatioDepth,
      shader_model_board_view_uInverseRatioMain,
      cam );

   WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world, model_board_view );

   mdl_keyframe kf_res;
   if( localplayer.glider_orphan ){
      rb_extrapolate( &player_glide.rb, kf_res.co, kf_res.q );
      v3_fill( kf_res.s, 1.0f );

      v3f temp;
      q_mulv( kf_res.q, (v3f){0,-0.5f,0}, temp );
      v3_add( temp, kf_res.co, kf_res.co );
   }
   else {
      f32 target;
      if( localplayer.subsystem == k_player_subsystem_glide ) target = 1.0f;
      else target = 0.0f;

      /* TODO: TEMP */
      if( skaterift.activity != k_skaterift_replay )
         vg_slewf( &player_glide.t, target, vg.time_frame_delta * 4.0f );

      mdl_keyframe kf_backpack;

      struct skeleton *sk = &localplayer.skeleton;
      m4x3_mulv( localplayer.final_mtx[localplayer.id_chest ],
            sk->bones[localplayer.id_chest].co, 
            kf_backpack.co );

      v4f qyaw, qpitch, qchest, q;
      q_axis_angle( qyaw,   (v3f){0,1,0}, VG_TAUf*0.25f );
      q_axis_angle( qpitch, (v3f){1,0,0}, VG_TAUf*0.25f );
      m3x3_q( localplayer.final_mtx[ localplayer.id_chest ], qchest );

      q_mul( qyaw, qpitch, q );
      q_mul( qchest, q, kf_backpack.q );
      q_normalize( kf_backpack.q );

      f32 scale;
      if( player_glide.t <= 0.0f ){
         f32 st  = player_glide.t + 1.0f,
             sst = vg_smoothstepf(st),
             isst= 1.0f - sst;
         scale = vg_lerpf( 0.0f, 0.2f, sst );

         v4f qspin;
         q_axis_angle( qspin, (v3f){0,0,1}, VG_TAUf * isst * 0.5f );
         q_mul( kf_backpack.q, qspin, kf_backpack.q );
         kf_backpack.co[1] += isst * 1.0f;
         v3_muladds( kf_backpack.co, 
                     localplayer.final_mtx[ localplayer.id_chest ][0],
                     isst * 0.25f,
                     kf_backpack.co );
      }
      else{
         scale = vg_lerpf( 0.2f, 1.0f, vg_smoothstepf(player_glide.t) );
      }


      v3_fill( kf_backpack.s, scale );

      v3_copy( pose->root_co, kf_res.co );
      v4_copy( pose->root_q, kf_res.q );
      v3_fill( kf_res.s, scale );

      f32 blend = vg_smoothstepf( vg_maxf( 0, player_glide.t ) );
      keyframe_lerp( &kf_backpack, &kf_res, blend, &kf_res );
   }
      
   m4x3f mmdl;
   q_m3x3( kf_res.q, mmdl );
   m3x3_scale( mmdl, kf_res.s );
   v3_copy( kf_res.co, mmdl[3] );

   render_glider_model( cam, world, mmdl, k_board_shader_player );

   /* totally FUCKED */
   v4_copy( kf_res.q, player_glide.remote_animator.root_q );
   v3_copy( kf_res.co, player_glide.remote_animator.root_co );
   player_glide.remote_animator.s = kf_res.s[0];
}

static void player_glide_render_effects( camera *cam ){
   v3f co, temp;
   v4f q;
   rb_extrapolate( &player_glide.rb, co, q );
   q_mulv( q, (v3f){0,-0.5f,0}, temp );
   v3_add( temp, co, co );

   f32 alpha = vg_maxf( (fabsf(player_glide.info_lift[2])-1.0f), 0.0f ) /18.0f;

   for( u32 i=0; i<player_glide.trail_count; i ++ ){
      v3f vvert;
      q_mulv( q, player_glide.trail_positions[i], vvert );
      v3_add( co, vvert, vvert );
      
      trail_system_update( &trails_glider[i], vg.time_delta, vvert,
                           localplayer.rb.to_world[1], alpha );
                           
      trail_system_prerender( &trails_glider[i] );
      trail_system_render( &trails_glider[i], &skaterift.cam );
   }
}

#endif /* PLAYER_GLIDE_C */