X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_glide.c;h=6b5930b9c2f26bed2d4d17ad1f28d3d902303831;hb=95f6ef1a859423a0d9554ac6a9f4c6cbd8bb540c;hp=5cf1dd11a6ce15fd040f743063198e1644fa4a78;hpb=a5d462e0b43a8f0c4a36a17a11636a56f324e45f;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_glide.c b/player_glide.c
index 5cf1dd1..6b5930b 100644
--- a/player_glide.c
+++ b/player_glide.c
@@ -1,12 +1,74 @@
-#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"
+#include "input.h"
+#include "skaterift.h"
+
+#include "player_dead.h"
+#include "player_skate.h"
+
+trail_system trails_glider[] = {
+   {
+      .width = 0.035f,
+      .lifetime = 5.0f,
+      .min_dist = 0.5f
+   },
+   {
+      .width = 0.035f,
+      .lifetime = 5.0f,
+      .min_dist = 0.5f
+   },
+};
+
+struct player_glide player_glide =
+{
+   .parts = {
+      {
+         .co    = { 1.0f, 0.5f, -1.0f },
+         .euler = { VG_TAUf*0.25f,  VG_TAUf*0.125f, 0.0f },
+         .shape = k_rb_shape_capsule,
+         .inf   = { .h = 2.82842712475f, .r = 0.25f },
+      },
+      {
+         .co    = { -1.0f, 0.5f, -1.0f },
+         .euler = { VG_TAUf*0.25f, -VG_TAUf*0.125f, 0.0f },
+         .shape = k_rb_shape_capsule,
+         .inf   = { .h = 2.82842712475f, .r = 0.25f },
+      },
+      {
+         .co    = {  0.0f, 0.5f, 1.0f },
+         .euler = { VG_TAUf*0.25f, VG_TAUf*0.25f, 0.0f },
+         .shape = k_rb_shape_capsule,
+         .inf   = { .h = 6.0f, .r = 0.25f },
+      },
+      {
+         .co    = {  0.0f, -0.5f, 0.0f },
+         .euler = { VG_TAUf*0.25f, VG_TAUf*0.25f, 0.0f },
+         .shape = k_rb_shape_capsule,
+         .inf   = { .h = 2.0f, .r = 0.25f },
+         .is_damage = 1,
+      },
+   }
+};
+
+struct player_subsystem_interface player_subsystem_glide = 
+{
+   .pre_update = player_glide_pre_update,
+   .update = player_glide_update,
+   .post_update = player_glide_post_update,
+   .animate = player_glide_animate,
+   .pose = player_glide_pose,
+   .post_animate = player_glide_post_animate,
+   .network_animator_exchange = player_glide_animator_exchange,
+   .im_gui = player_glide_im_gui,
+   .bind = player_glide_bind,
+
+   .animator_data = &player_glide.animator,
+   .animator_size = sizeof(player_glide.animator),
+   .name = "Glide"
+};
 
 static f32 k_glide_steer = 2.0f,
            k_glide_cl = 0.04f,
@@ -19,7 +81,8 @@ static f32 k_glide_steer = 2.0f,
 
 static i32 k_glide_pause = 0;
 
-static void player_glide_pre_update(void){
+void player_glide_pre_update(void)
+{
    if( button_down(k_srbind_use) ){
       localplayer.subsystem = k_player_subsystem_skate;
       localplayer.glider_orphan = 1;
@@ -43,12 +106,12 @@ static void player_glide_pre_update(void){
 
 static void massless_accel( rigidbody *rb, v3f delta, v3f impulse ){
    /* linear */
-   v3_muladds( rb->v, impulse, k_rb_delta, rb->v );
+   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, k_rb_delta, rb->w );
+   v3_muladds( rb->w, wa, vg.time_fixed_delta, rb->w );
 }
 
 static void calculate_lift( v3f vl, f32 aoa_bias, 
@@ -62,7 +125,7 @@ static void calculate_lift( v3f vl, f32 aoa_bias,
    
    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 */
+       cl     = aoa / VG_PIf,
        L      = windv2 * cl * power;
 
    v3f lift_dir;
@@ -85,7 +148,8 @@ static void calculate_drag( v3f vl, f32 cd, v3f out_force ){
 /*
  * Returns true if the bottom sphere is hit 
  */
-static bool glider_physics( v2f steer ){
+bool glider_physics( v2f steer )
+{
    rigidbody *rb = &player_glide.rb;
 
    /* lift */
@@ -131,12 +195,12 @@ static bool glider_physics( v2f steer ){
    v3_add( F, Fdrag, F );
 
    m3x3_mulv( rb->to_world, F, F );
-   v3_muladds( rb->v, F, k_rb_delta, rb->v );
+   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, k_rb_delta, rb->w );
+   v3_muladds( rb->w, Fw, vg.time_fixed_delta, rb->w );
 
 
    /* 
@@ -193,7 +257,8 @@ static bool glider_physics( v2f steer ){
       }
    }
 
-   rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
+   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 );
    
@@ -203,17 +268,24 @@ static bool glider_physics( v2f steer ){
    return bottom_hit;
 }
 
-static void player_glide_update(void){
+void player_glide_update(void)
+{
    v2f steer;
    joystick_state( k_srjoystick_steer, steer );
 
-   if( glider_physics( 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;
    }
+
+   if( !world_water_player_safe( world_current_instance(), 1.0f ) )
+      return;
 }
 
-static void player_glide_post_update(void){
+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 );
@@ -221,27 +293,31 @@ static void player_glide_post_update(void){
    rb_update_matrices( &localplayer.rb );
 }
 
-static void player_glide_animate(void){
+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 ){
+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 );
 
-   /* TODO: again the offset is wrong */
    v3f temp;
-   q_mulv( pose->root_q, (v3f){0,-0.5f,0}, 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){
+void player_glide_post_animate(void)
+{
    if( localplayer.cam_control.camera_mode == k_cam_firstperson )
       localplayer.cam_velocity_influence = 0.0f;
    else
@@ -254,7 +330,25 @@ static void player_glide_post_animate(void){
    localplayer.cam_dist = 2.0f + v3_length( localplayer.rb.v )*0.2f;
 }
 
-static void player_glide_im_gui(void){
+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 );
+}
+
+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 );
+}
+
+void player_glide_im_gui(void)
+{
    player__debugtext( 1, "Nothing here" );
    player__debugtext( 1, " lift: %.2f %.2f %.2f", 
                            player_glide.info_lift[0],
@@ -270,8 +364,27 @@ static void player_glide_im_gui(void){
                            player_glide.info_drag[2] );
 }
 
-static void player_glide_bind(void){
+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;
+}
+
+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 );
@@ -283,9 +396,9 @@ static void player_glide_bind(void){
    VG_VAR_F32( k_glide_balance, flags=mask );
    VG_VAR_F32( k_glide_wing_orient, flags=mask );
 
-   f32 mass = 0.0f,
-       k_density = 8.0f,
-       k_inertia_scale = 1.0f;
+   vg_console_reg_cmd( "spawn_glider", ccmd_player_glider_spawn, NULL );
+
+   f32 mass = 0.0f,k_density = 8.0f;
    m3x3f I;
    m3x3_zero( I );
 
@@ -339,40 +452,49 @@ static void player_glide_bind(void){
    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 );
+   mdl_async_full_load_std( mdl );
 
-   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 );
+   /* load trail positions */
+   mdl_array_ptr markers;
+   MDL_LOAD_ARRAY( mdl, &markers, ent_marker, vg_mem.scratch );
+   mdl_close( mdl );
 
-   for( u32 i=0; i<count; i ++ ){
-      vg_linear_clear( vg_mem.scratch );
-      player_glide.glider_textures[i+1] = vg.tex_missing;
+   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 ++ ] );
 
-      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] );
+      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){
+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 );
 
@@ -394,9 +516,78 @@ static void player_glide_transition(void){
    player__begin_holdout( (v3f){0,0,0} );
 }
 
-static void player_glide_render( camera *cam, world_instance *world,
-                                 player_pose *pose ){
+void render_glider_model( vg_camera *cam, world_instance *world,
+                          m4x3f mmdl, enum board_shader shader )
+{
+   u32 current_mat = 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;
+         }
+
+         if( sm->material_id != current_mat )
+         {
+            mdl_material *mat = mdl_arritm( &mdl->materials,sm->material_id-1 );
+            GLuint tex = vg.tex_missing;
+
+            if( mat->shader == k_shader_standard )
+            {
+               struct shader_props_standard *props = mat->props.compiled;
+
+               u32 index = props->tex_diffuse-1;
+               mdl_texture *ptex = mdl_arritm( &mdl->textures, index );
+               tex = ptex->glname;
+            }
+
+            glBindTexture( GL_TEXTURE_2D, tex );
+            current_mat = sm->material_id;
+         }
+
+         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
+ */
+void player_glide_render( vg_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;
@@ -405,8 +596,7 @@ static void player_glide_render( camera *cam, world_instance *world,
    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);
+   shader_model_board_view_uDepthMode(1);
    depth_compare_bind(
       shader_model_board_view_uTexSceneDepth,
       shader_model_board_view_uInverseRatioDepth,
@@ -428,7 +618,10 @@ static void player_glide_render( camera *cam, world_instance *world,
       f32 target;
       if( localplayer.subsystem == k_player_subsystem_glide ) target = 1.0f;
       else target = 0.0f;
-      vg_slewf( &player_glide.t, target, vg.time_frame_delta * 4.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;
 
@@ -482,38 +675,33 @@ static void player_glide_render( camera *cam, world_instance *world,
    m3x3_scale( mmdl, kf_res.s );
    v3_copy( kf_res.co, mmdl[3] );
 
-   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 );
+   render_glider_model( cam, world, mmdl, k_board_shader_player );
 
-      shader_model_board_view_uMdl( mmmdl );
+   /* 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];
+}
 
-      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;
-         }
+void player_glide_render_effects( vg_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 );
 
-         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;
-         }
+   f32 alpha = vg_maxf( (fabsf(player_glide.info_lift[2])-1.0f), 0.0f ) /18.0f;
 
-         mdl_draw_submesh( sm );
-      }
+   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 */