X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_glide.c;h=af44ea6e806ed6f30088f811d679fc1e841c271c;hb=888e62fcd8f9777cee774fbb8fab2e52660303a7;hp=3091e57e2173c123c37206ad8eb6a10492102046;hpb=171b279a489f1b906265759b33249f61d48d3d5f;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_glide.c b/player_glide.c
index 3091e57..af44ea6 100644
--- a/player_glide.c
+++ b/player_glide.c
@@ -4,6 +4,11 @@
 #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,
@@ -16,6 +21,25 @@ static f32 k_glide_steer = 2.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 ){
@@ -59,12 +83,12 @@ static void calculate_drag( v3f vl, f32 cd, v3f out_force ){
    v3_muls( vl, -cd*v2, out_force );
 }
 
-static void player_glide_update(void){
+/*
+ * Returns true if the bottom sphere is hit 
+ */
+static bool glider_physics( v2f steer ){
    rigidbody *rb = &player_glide.rb;
 
-   v2f steer;
-   joystick_state( k_srjoystick_steer, steer );
-
    /* lift */
    v3f vl, wl;
    m3x3_mulv( rb->to_local, rb->v, vl );
@@ -99,7 +123,7 @@ static void player_glide_update(void){
 
    if( player_glide.ticker ){
       player_glide.ticker --;
-      return;
+      return 0;
    }
    player_glide.ticker += k_glide_pause;
 
@@ -115,12 +139,15 @@ static void player_glide_update(void){
    m3x3_mulv( rb->to_world, Fw, Fw );
    v3_muladds( rb->w, Fw, k_rb_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 );
@@ -154,6 +181,10 @@ static void player_glide_update(void){
                                   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;
@@ -166,9 +197,22 @@ static void player_glide_update(void){
    rb_presolve_contacts( rb_contact_buffer, 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){
@@ -188,10 +232,15 @@ static void player_glide_animate(void){
 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 );
 
-   skeleton_sample_anim( sk, player_glide.anim_temp, 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 );
 
-   v3_copy( animator->root_co, pose->root_co );
    v4_copy( animator->root_q, pose->root_q );
 }
 
@@ -204,6 +253,24 @@ static void player_glide_post_animate(void){
    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){
@@ -222,9 +289,25 @@ static void player_glide_im_gui(void){
                            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){
-   struct skeleton *sk = &localplayer.skeleton;
-   player_glide.anim_temp = skeleton_get_anim( sk, "idle_cycle+y" );
 
    u32 mask = VG_VAR_CHEAT|VG_VAR_PERSISTENT;
    VG_VAR_F32( k_glide_steer, flags=mask );
@@ -237,6 +320,8 @@ static void player_glide_bind(void){
    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,
        k_inertia_scale = 1.0f;
@@ -267,9 +352,9 @@ static void player_glide_bind(void){
          mass += pm;
 
          m3x3f pI;
-         rb_capsule_inertia( r, h, pm, pI );
-         rb_rotate_inertia( pI, player_glide.parts[i].mdl );
-         rb_translate_inertia( pI, pm, player_glide.parts[i].co );
+         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 ){
@@ -279,8 +364,8 @@ static void player_glide_bind(void){
 
          mass += pm;
          m3x3f pI;
-         rb_sphere_inertia( r, pm, pI );
-         rb_translate_inertia( pI, pm, player_glide.parts[i].co );
+         vg_sphere_inertia( r, pm, pI );
+         vg_translate_inertia( pI, pm, player_glide.parts[i].co );
          m3x3_add( I, pI, I );
       }
    }
@@ -288,6 +373,254 @@ static void player_glide_bind(void){
    /* 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;
+
+   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 */