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