player_model.h

   1 #ifndef CHARACTER_H
   2 #define CHARACTER_H
   3
   4 #include "common.h"
   5 #include "model.h"
   6 #include "rigidbody.h"
   7 #include "render.h"
   8 #include "skeleton.h"
   9 #include "world.h"
  10 #include "skeleton_animator.h"
  11 #include "shaders/viewchar.h"
  12
  13 static float k_ragdoll_floatyiness = 10.0f,
  14              k_ragdoll_floatydrag  = 1.0f;
  15
  16 vg_tex2d tex_characters = { .path = "textures/ch_gradient.qoi" };
  17
  18 static void character_register(void)
  19 {
  20    shader_viewchar_register();
  21 }
  22
  23 static void character_init(void)
  24 {
  25    vg_tex2d_init( (vg_tex2d *[]){ &tex_characters }, 1 );
  26 }
  27
  28 struct character
  29 {
  30    glmesh mesh;
  31    struct skeleton sk;
  32    struct skeleton_anim *anim_stand,
  33                         *anim_highg,
  34                         *anim_slide,
  35                         *anim_air,
  36                         *anim_push, *anim_push_reverse,
  37                         *anim_ollie, *anim_ollie_reverse,
  38                         *anim_grabs, *anim_stop,
  39                         *anim_walk, *anim_run, *anim_idle;
  40
  41    u32 id_hip,
  42        id_ik_hand_l,
  43        id_ik_hand_r,
  44        id_ik_elbow_l,
  45        id_ik_elbow_r,
  46        id_head;
  47
  48    v3f cam_pos;
  49
  50    struct ragdoll_part
  51    {
  52       u32 bone_id;
  53       v3f offset;
  54
  55       u32 use_limits;
  56       v3f limits[2];
  57
  58       rigidbody  rb;
  59       u32 parent;
  60    }
  61    *ragdoll;
  62    u32 ragdoll_count;
  63
  64    int shoes[2];
  65 };
  66
  67 static int character_load( struct character *ch, const char *name )
  68 {
  69    char buf[64];
  70
  71    snprintf( buf, sizeof(buf)-1, "models/%s.mdl", name );
  72    mdl_header *src = mdl_load( buf );
  73
  74    if( !src )
  75       return 0;
  76
  77    mdl_unpack_glmesh( src, &ch->mesh );
  78
  79    skeleton_setup( &ch->sk, src );
  80    ch->anim_stand = skeleton_get_anim( &ch->sk, "pose_stand" );
  81    ch->anim_highg = skeleton_get_anim( &ch->sk, "pose_highg" );
  82    ch->anim_slide = skeleton_get_anim( &ch->sk, "pose_slide" );
  83    ch->anim_air   = skeleton_get_anim( &ch->sk, "pose_air" );
  84    ch->anim_push  = skeleton_get_anim( &ch->sk, "push" );
  85    ch->anim_push_reverse = skeleton_get_anim( &ch->sk, "push_reverse" );
  86    ch->anim_ollie = skeleton_get_anim( &ch->sk, "ollie" );
  87    ch->anim_ollie_reverse = skeleton_get_anim( &ch->sk, "ollie_reverse" );
  88    ch->anim_grabs = skeleton_get_anim( &ch->sk, "grabs" );
  89    ch->anim_walk  = skeleton_get_anim( &ch->sk, "walk" );
  90    ch->anim_run   = skeleton_get_anim( &ch->sk, "run" );
  91    ch->anim_idle  = skeleton_get_anim( &ch->sk, "idle_cycle" );
  92
  93    ch->id_hip = skeleton_bone_id( &ch->sk, "hips" );
  94    ch->id_ik_hand_l = skeleton_bone_id( &ch->sk, "hand.IK.L" );
  95    ch->id_ik_hand_r = skeleton_bone_id( &ch->sk, "hand.IK.R" );
  96    ch->id_ik_elbow_l = skeleton_bone_id( &ch->sk, "elbow.L" );
  97    ch->id_ik_elbow_r = skeleton_bone_id( &ch->sk, "elbow.R" );
  98    ch->id_head = skeleton_bone_id( &ch->sk, "head" );
  99
 100    /* setup ragdoll */
 101
 102    if( ch->sk.collider_count )
 103    {
 104       vg_info( "Alloc: %d\n", ch->sk.collider_count );
 105       ch->ragdoll = malloc(sizeof(struct ragdoll_part) * ch->sk.collider_count);
 106       ch->ragdoll_count = 0;
 107
 108       for( u32 i=0; i<ch->sk.bone_count; i ++ )
 109       {
 110          struct skeleton_bone *bone = &ch->sk.bones[i];
 111
 112          if( bone->collider )
 113          {
 114             struct ragdoll_part *rp = &ch->ragdoll[ ch->ragdoll_count ++ ];
 115             rp->bone_id = i;
 116
 117             v3f delta;
 118             v3_sub( bone->hitbox[1], bone->hitbox[0], delta );
 119             v3_muls( delta, 0.5f, delta );
 120
 121             v3_add( bone->hitbox[0], delta, rp->offset );
 122
 123             v3_copy( delta, rp->rb.bbx[1] );
 124             v3_muls( delta, -1.0f, rp->rb.bbx[0] );
 125
 126             q_identity( rp->rb.q );
 127             v3_add( bone->co, rp->offset, rp->rb.co );
 128             rp->rb.type = k_rb_shape_box;
 129             rp->rb.is_world = 0;
 130             rp->parent = 0xffffffff;
 131
 132             if( bone->parent )
 133             {
 134                for( u32 j=0; j<ch->ragdoll_count; j++ )
 135                {
 136                   if( ch->ragdoll[ j ].bone_id == bone->parent )
 137                   {
 138                      rp->parent = j;
 139                      break;
 140                   }
 141                }
 142             }
 143
 144             /* TODO: refactor to use this style elswhere */
 145             struct mdl_node *pnode = mdl_node_from_id( src, bone->orig_node );
 146             struct classtype_bone *bone_inf = mdl_get_entdata( src, pnode );
 147
 148             rp->use_limits = bone_inf->use_limits;
 149             v3_copy( bone_inf->angle_limits[0], rp->limits[0] );
 150             v3_copy( bone_inf->angle_limits[1], rp->limits[1] );
 151
 152             rb_init( &rp->rb );
 153          }
 154       }
 155    }
 156
 157    free( src );
 158    return 1;
 159 }
 160
 161 static void character_eval( struct character *ch ){}
 162 static void character_draw( struct character *ch, float temp, m4x3f camera ){}
 163 static void character_init_ragdoll_joints( struct character *ch ){}
 164 static void character_init_ragdoll( struct character *ch ){}
 165 static void character_ragdoll_go( struct character *ch, v3f pos ){}
 166
 167 static void character_mimic_ragdoll( struct character *ch )
 168 {
 169    for( int i=0; i<ch->ragdoll_count; i++ )
 170    {
 171       struct ragdoll_part *part = &ch->ragdoll[i];
 172       m4x3f offset;
 173       m3x3_identity(offset);
 174       v3_negate( part->offset, offset[3] );
 175       m4x3_mul( part->rb.to_world, offset, ch->sk.final_mtx[part->bone_id] );
 176    }
 177
 178    skeleton_apply_inverses( &ch->sk );
 179 }
 180
 181 static void character_ragdoll_copypose( struct character *ch, v3f v )
 182 {
 183    for( int i=0; i<ch->ragdoll_count; i++ )
 184    {
 185       struct ragdoll_part *part = &ch->ragdoll[i];
 186
 187       v3f pos, offset;
 188       u32 bone = part->bone_id;
 189
 190       m4x3_mulv( ch->sk.final_mtx[bone], ch->sk.bones[bone].co, pos );
 191       m3x3_mulv( ch->sk.final_mtx[bone], part->offset, offset );
 192       v3_add( pos, offset, part->rb.co );
 193       m3x3_q( ch->sk.final_mtx[bone], part->rb.q );
 194       v3_copy( v, part->rb.v );
 195       v3_zero( part->rb.w );
 196
 197       rb_update_transform( &part->rb );
 198    }
 199 }
 200
 201 static void character_debug_ragdoll( struct character *ch )
 202 {
 203    for( u32 i=0; i<ch->ragdoll_count; i ++ )
 204       rb_debug( &ch->ragdoll[i].rb, 0xff00ff00 );
 205 }
 206
 207 static void character_ragdoll_iter( struct character *ch )
 208 {
 209    rb_solver_reset();
 210
 211    for( int i=0; i<ch->ragdoll_count; i ++ )
 212       rb_collide( &ch->ragdoll[i].rb, &world.rb_geo );
 213
 214    rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
 215
 216    v3f rv;
 217
 218    float shoe_vel[2] = {0.0f,0.0f};
 219    for( int i=0; i<2; i++ )
 220       if( ch->shoes[i] )
 221          shoe_vel[i] = v3_length( ch->ragdoll[i].rb.v );
 222
 223    for( int j=0; j<ch->ragdoll_count; j++ )
 224    {
 225       struct ragdoll_part *pj = &ch->ragdoll[j];
 226       struct skeleton_bone *bj = &ch->sk.bones[pj->bone_id];
 227
 228       if( pj->parent != 0xffffffff )
 229       {
 230          struct ragdoll_part *pp = &ch->ragdoll[pj->parent];
 231          struct skeleton_bone *bp = &ch->sk.bones[pp->bone_id];
 232
 233          v3f lca, lcb;
 234          v3_negate( pj->offset, lca );
 235          v3_add( bp->co, pp->offset, lcb );
 236          v3_sub( bj->co, lcb, lcb );
 237
 238          rb_debug_constraint_position( &pj->rb, lca, &pp->rb, lcb );
 239
 240          if( pj->use_limits )
 241          {
 242             rb_debug_constraint_limits( &pj->rb, &pp->rb, lca, pj->limits );
 243          }
 244       }
 245
 246       v4f plane = {0.0f,1.0f,0.0f,0.0f};
 247       rb_effect_simple_bouyency( &pj->rb, plane, k_ragdoll_floatyiness,
 248                                                  k_ragdoll_floatydrag );
 249    }
 250
 251    /* CONSTRAINTS */
 252    for( int i=0; i<10; i++ )
 253    {
 254       rb_solve_contacts( rb_contact_buffer, rb_contact_count );
 255
 256       for( int j=0; j<ch->ragdoll_count; j++ )
 257       {
 258          struct ragdoll_part *pj = &ch->ragdoll[j];
 259          struct skeleton_bone *bj = &ch->sk.bones[pj->bone_id];
 260
 261          if( pj->parent != 0xffffffff && pj->use_limits )
 262          {
 263             struct ragdoll_part *pp = &ch->ragdoll[pj->parent];
 264             struct skeleton_bone *bp = &ch->sk.bones[pp->bone_id];
 265
 266             v3f lca, lcb;
 267             v3_negate( pj->offset, lca );
 268             v3_add( bp->co, pp->offset, lcb );
 269             v3_sub( bj->co, lcb, lcb );
 270
 271             rb_constraint_position( &pj->rb, lca, &pp->rb, lcb );
 272
 273             rb_constraint_limits( &pj->rb, lca, &pp->rb, lcb, pj->limits );
 274          }
 275       }
 276    }
 277
 278    /* INTEGRATION */
 279    for( int i=0; i<ch->ragdoll_count; i++ )
 280       rb_iter( &ch->ragdoll[i].rb );
 281
 282    /* SHOES */
 283
 284    for( int i=0; i<ch->ragdoll_count; i++ )
 285       rb_update_transform( &ch->ragdoll[i].rb );
 286 }
 287
 288 #endif