From 07d0834b13ecf5de312cf3578e8aca8f106f5ef1 Mon Sep 17 00:00:00 2001 From: hgn Date: Thu, 26 Jan 2023 01:31:23 +0000 Subject: [PATCH] LPR - Walk/Anim --- player_device_walk.h | 140 +++++++++++++++++++++++++++++----- player_interface.h | 68 ++++++++++++++++- player_model.h | 64 +++++++++++++++- player_ragdoll.h | 178 +++++++++++++++++++++++++------------------ skaterift.c | 83 ++++++++++++++++---- skeleton.h | 8 +- 6 files changed, 426 insertions(+), 115 deletions(-) diff --git a/player_device_walk.h b/player_device_walk.h index 0559acd..a0ea96b 100644 --- a/player_device_walk.h +++ b/player_device_walk.h @@ -2,6 +2,8 @@ #define PLAYER_DEVICE_WALK_H #include "player_interface.h" +#include "skeleton.h" +#include "player_model.h" VG_STATIC float k_walkspeed = 10.0f, @@ -31,6 +33,15 @@ struct player_device_walk state; enum mdl_surface_prop surface; + + struct skeleton_anim *anim_walk, *anim_run, *anim_idle, *anim_jump; + + float blend_fly, + blend_run, + blend_walk, + + move_speed, + walk_timer; }; VG_STATIC void player_walk_pre_update( player_interface *player, @@ -119,6 +130,8 @@ VG_STATIC void player_walk_update( player_interface *player, if( v2_length2(walk) > 0.001f ) v2_normalize_clamp( walk ); + w->move_speed = v2_length( walk ); + /* * Collision detection */ @@ -194,7 +207,6 @@ VG_STATIC void player_walk_update( player_interface *player, if( v2_length2(walk) > 0.001f ) { - vg_info( "%f %f\n", walk[0], walk[1] ); player_accelerate( player->rb.v, movedir, nominal_speed, accel_speed ); v3_normalize( movedir ); } @@ -284,21 +296,16 @@ VG_STATIC void player_walk_update( player_interface *player, VG_STATIC void player_walk_post_update( player_interface *player, player_attachment *at ) { - -} - -VG_STATIC void player_walk_get_camera( player_interface *player, - player_attachment *at, camera *cam ) -{ struct player_device_walk *w = at->storage; + m4x3f mtx; + m3x3_identity( mtx ); + v3_add( player->rb.co, (v3f){0.0f, 1.0f, 0.0f}, mtx[3] ); + float substep = vg_clampf( vg.accumulator / k_rb_delta, 0.0f, 1.0f ); - v3f pos; - v3_muladds( player->rb.co, player->rb.v, k_rb_delta*substep, pos ); + v3_muladds( mtx[3], player->rb.v, k_rb_delta*substep, mtx[3] ); - v3_add( pos, (v3f){0.0f,1.8f,0.0f}, cam->pos ); - v3_copy( w->state.angles, cam->angles ); - cam->fov = 90.0f; + debug_capsule( mtx, w->collider.radius, w->collider.height, VG__YELOW ); } VG_STATIC void player_walk_ui( player_interface *player, @@ -312,13 +319,110 @@ VG_STATIC void player_walk_ui( player_interface *player, player->rb.co[2] ); } -player_device player_device_walk = +VG_STATIC void player_walk_bind( player_interface *player, + player_attachment *at ) +{ + struct player_device_walk *w = at->storage; + struct player_avatar *av = player->playeravatar; + struct skeleton *sk = &av->sk; + + w->anim_idle = skeleton_get_anim( sk, "idle_cycle" ); + w->anim_walk = skeleton_get_anim( sk, "walk" ); + w->anim_run = skeleton_get_anim( sk, "run" ); + w->anim_jump = skeleton_get_anim( sk, "jump" ); +} + +VG_STATIC void player_walk_pose( player_interface *player, + player_attachment *at, + player_pose pose, m4x3f transform ) +{ + struct player_device_walk *w = at->storage; + struct skeleton *sk = &player->playeravatar->sk; + + { + float fly = (w->state.activity == k_walk_activity_air)? 1.0f: 0.0f, + rate; + + if( w->state.activity == k_walk_activity_air ) + rate = 2.4f; + else + rate = 9.0f; + + w->blend_fly = vg_lerpf( w->blend_fly, fly, rate*vg.time_delta ); + w->blend_run = vg_lerpf( w->blend_run, + w->move_speed * + (1.0f + player->input_walk->button.value*0.5f), + 2.0f*vg.time_delta ); + } + + player_pose apose, bpose; + + if( w->move_speed > 0.025f ) + { + /* TODO move */ + float walk_norm = 30.0f/(float)w->anim_walk->length, + run_norm = 30.0f/(float)w->anim_run->length, + walk_adv = vg_lerpf( walk_norm, run_norm, w->move_speed ); + + w->walk_timer += walk_adv * vg.time_delta; + } + else + { + w->walk_timer = 0.0f; + } + + float walk_norm = (float)w->anim_walk->length/30.0f, + run_norm = (float)w->anim_run->length/30.0f, + t = w->walk_timer, + l = vg_clampf( w->blend_run*15.0f, 0.0f, 1.0f ), + idle_walk = vg_clampf( (w->blend_run-0.1f)/(1.0f-0.1f), 0.0f, 1.0f ); + + /* walk/run */ + skeleton_sample_anim( sk, w->anim_walk, t*walk_norm, apose ); + skeleton_sample_anim( sk, w->anim_run, t*run_norm, bpose ); + + skeleton_lerp_pose( sk, apose, bpose, l, apose ); + + /* idle */ + skeleton_sample_anim( sk, w->anim_idle, vg.time*0.1f, bpose ); + skeleton_lerp_pose( sk, apose, bpose, 1.0f-idle_walk, apose ); + + /* air */ + skeleton_sample_anim( sk, w->anim_jump, vg.time*0.6f, bpose ); + skeleton_lerp_pose( sk, apose, bpose, w->blend_fly, pose ); + + /* Create transform matrix */ + m3x3f rotation_mtx; + v4f rot; + q_axis_angle( rot, (v3f){0.0f,1.0f,0.0f}, -w->state.angles[0]-VG_PIf*0.5f ); + q_m3x3( rot, rotation_mtx ); + + rb_extrapolate_transform( &player->rb, transform ); + m3x3_copy( rotation_mtx, transform ); +} + +VG_STATIC void player_walk_get_camera( player_interface *player, + player_attachment *at, camera *cam ) +{ + struct player_device_walk *w = at->storage; + struct player_avatar *av = player->playeravatar; + + /* FIXME: viewpoint entity */ + v3f vp = {-0.1f,1.8f,0.0f}; + m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, cam->pos ); + v3_copy( w->state.angles, cam->angles ); + cam->fov = 90.0f; +} + +VG_STATIC player_device player_device_walk = { - .pre_update = player_walk_pre_update, - .update = player_walk_update, - .post_update = player_walk_post_update, - .get_camera = player_walk_get_camera, - .debug_ui = player_walk_ui + .pre_update = player_walk_pre_update, + .update = player_walk_update, + .post_update = player_walk_post_update, + .get_camera = player_walk_get_camera, + .debug_ui = player_walk_ui, + .bind = player_walk_bind, + .pose = player_walk_pose }; #endif /* PLAYER_DEVICE_WALK_H */ diff --git a/player_interface.h b/player_interface.h index c890166..f28d7a8 100644 --- a/player_interface.h +++ b/player_interface.h @@ -4,6 +4,8 @@ #include "model.h" #include "camera.h" #include "rigidbody.h" +#include "player_ragdoll.h" +#include "player_model.h" #include "world.h" typedef struct player_device player_device; @@ -35,15 +37,23 @@ struct player_interface *input_use, *input_reset, *input_grab; + + struct player_avatar *playeravatar; + glmesh *playermesh; + struct player_ragdoll ragdoll; }; +/* FIXME: yo */ +vg_tex2d tex_characters = { .path = "textures/ch_gradient.qoi" }; + struct player_device { + void (* bind ) ( player_interface *player, player_attachment *at ); void (* pre_update) ( player_interface *player, player_attachment *at ); void (* update) ( player_interface *player, player_attachment *at ); void (* post_update)( player_interface *player, player_attachment *at ); void (* pose) ( player_interface *player, player_attachment *at, - player_pose pose ); + player_pose pose, m4x3f transform ); void (* get_camera) ( player_interface *player, player_attachment *at, camera *cam ); @@ -127,11 +137,25 @@ VG_STATIC void player_interface_create_player( player_interface *inst ) m4x3_identity( inst->rb.to_local ); } +VG_STATIC void player_use_avatar( player_interface *player, + struct player_avatar *av ) +{ + player->playeravatar = av; + player_setup_ragdoll_from_avatar( &player->ragdoll, av ); +} + +VG_STATIC void player_use_mesh( player_interface *player, glmesh *mesh ) +{ + player->playermesh = mesh; +} + VG_STATIC void player_use_device( player_interface *player, player_device *dev, void *storage ) { player->dev.device = dev; player->dev.storage = storage; + + player->dev.device->bind( player, &player->dev ); } VG_STATIC void player_pre_update( player_interface *player ) @@ -157,8 +181,6 @@ VG_STATIC void player_post_update( player_interface *player ) if( player->dev.device->post_update ) player->dev.device->post_update( player, &player->dev ); - if( player->dev.device->get_camera ) - player->dev.device->get_camera( player, &player->dev, &player->cam ); #if 0 camera_update_transform( &player->cam ); camera_update_view( &player->cam ); @@ -177,6 +199,43 @@ VG_STATIC void player_pre_render( player_interface *player ) } #endif +VG_STATIC void player_pre_render( player_interface *player ) +{ + player_pose pose; + m4x3f transform; + + player->dev.device->pose( player, &player->dev, pose, transform ); + + struct skeleton *sk = &player->playeravatar->sk; + + skeleton_apply_pose( sk, pose, k_anim_apply_defer_ik ); + skeleton_apply_ik_pass( sk ); + skeleton_apply_pose( sk, pose, k_anim_apply_deffered_only ); + skeleton_apply_inverses( sk ); + skeleton_apply_transform( sk, transform ); + skeleton_debug( sk ); + + player->dev.device->get_camera( player, &player->dev, &player->cam ); + /* TODO: if dead copy ragdoll.. . */ +} + +VG_STATIC void player_render( camera *cam, player_interface *player ) +{ + shader_viewchar_use(); + vg_tex2d_bind( &tex_characters, 0 ); + shader_viewchar_uTexMain( 0 ); + shader_viewchar_uCamera( cam->transform[3] ); + shader_viewchar_uPv( cam->mtx.pv ); + shader_link_standard_ub( _shader_viewchar.id, 2 ); + glUniformMatrix4x3fv( _uniform_viewchar_uTransforms, + player->playeravatar->sk.bone_count, + 0, + (float *)player->playeravatar->sk.final_mtx ); + + mesh_bind( player->playermesh ); + mesh_draw( player->playermesh ); +} + VG_STATIC void player_debugtext( int size, const char *fmt, ... ) { char buffer[ 1024 ]; @@ -198,11 +257,12 @@ VG_STATIC void player_ui( player_interface *player ) { vg_uictx.cursor[0] = vg.window_x - 200; vg_uictx.cursor[1] = 0; - vg_uictx.cursor[2] = 0; + vg_uictx.cursor[2] = 200; vg_uictx.cursor[3] = 200; struct ui_vert *b = ui_fill_rect( vg_uictx.cursor, 0x70000000 ); + vg_uictx.cursor[0] = vg.window_x; player->dev.device->debug_ui( player, &player->dev ); b[2].co[1] = vg_uictx.cursor[1]; diff --git a/player_model.h b/player_model.h index 4a09b90..7bf801c 100644 --- a/player_model.h +++ b/player_model.h @@ -13,12 +13,71 @@ #endif #include "model.h" +#include "skeleton.h" #include "player_ragdoll.h" +#include "rigidbody.h" + #include "shaders/viewchar.h" -vg_tex2d tex_characters = { .path = "textures/ch_gradient.qoi" }; +struct player_avatar +{ + mdl_context meta; + struct skeleton sk; + + v3f cam_pos; /* FIXME ? */ + +#if 0 + struct skeleton_anim *anim_stand, + *anim_highg, + *anim_slide, + *anim_air, + *anim_push, *anim_push_reverse, + *anim_ollie, *anim_ollie_reverse, + *anim_grabs, *anim_stop, + *anim_walk, *anim_run, *anim_idle, + *anim_jump; +#endif + + u32 id_hip, + id_ik_hand_l, + id_ik_hand_r, + id_ik_elbow_l, + id_ik_elbow_r, + id_head, + id_ik_foot_l, + id_ik_foot_r, + id_board; +}; + +#if 0 +glmesh player_meshes[3]; +#endif + +VG_STATIC void player_avatar_load( struct player_avatar *av, const char *path ) +{ + /* load in reference player model, with animations and such */ + /* FIXME: This is allocated as un-freeable systems memory */ + + mdl_open( &av->meta, path ); + mdl_load_metadata( &av->meta, vg_mem.rtmemory ); + mdl_load_anim_data( &av->meta, vg_mem.rtmemory ); + + struct skeleton *sk = &av->sk; + skeleton_setup( sk, vg_mem.rtmemory, &av->meta ); + + av->id_hip = skeleton_bone_id( sk, "hips" ); + av->id_ik_hand_l = skeleton_bone_id( sk, "hand.IK.L" ); + av->id_ik_hand_r = skeleton_bone_id( sk, "hand.IK.R" ); + av->id_ik_elbow_l = skeleton_bone_id( sk, "elbow.L" ); + av->id_ik_elbow_r = skeleton_bone_id( sk, "elbow.R" ); + av->id_head = skeleton_bone_id( sk, "head" ); + av->id_ik_foot_l = skeleton_bone_id( sk, "foot.IK.L" ); + av->id_ik_foot_r = skeleton_bone_id( sk, "foot.IK.R" ); + av->id_board = skeleton_bone_id( sk, "board" ); +} -VG_STATIC void player_model_init(void) +#if 0 +VG_STATIC void player_load_reference( struct player_model *pmodel ) { shader_viewchar_register(); vg_acquire_thread_sync(); @@ -130,5 +189,6 @@ VG_STATIC void player_model_init(void) } } } +#endif #endif diff --git a/player_ragdoll.h b/player_ragdoll.h index 0d6d74d..db01ece 100644 --- a/player_ragdoll.h +++ b/player_ragdoll.h @@ -1,7 +1,12 @@ #ifndef PLAYER_RAGDOLL_H #define PLAYER_RAGDOLL_H -#include "player.h" +#define VG_GAME +#include "vg/vg.h" +#include "skeleton.h" +#include "rigidbody.h" +#include "player_model.h" +#include "world.h" VG_STATIC float k_ragdoll_floatyiness = 20.0f, k_ragdoll_floatydrag = 1.0f, @@ -12,6 +17,35 @@ VG_STATIC int k_ragdoll_div = 1, k_ragdoll_debug_collider = 1, k_ragdoll_debug_constraints = 0; +struct player_ragdoll +{ + struct ragdoll_part + { + u32 bone_id; + + /* Collider transform relative to bone */ + m4x3f collider_mtx, + inv_collider_mtx; + + u32 use_limits; + v3f limits[2]; + + rigidbody rb; + u32 parent; + u32 colour; + } + parts[32]; + u32 part_count; + + rb_constr_pos position_constraints[32]; + u32 position_constraints_count; + + rb_constr_swingtwist cone_constraints[32]; + u32 cone_constraints_count; + + int shoes[2]; +}; + VG_STATIC void player_init_ragdoll_bone_collider( struct skeleton_bone *bone, struct ragdoll_part *rp ) { @@ -83,10 +117,11 @@ VG_STATIC void player_init_ragdoll_bone_collider( struct skeleton_bone *bone, /* * Get parent index in the ragdoll */ -VG_STATIC u32 ragdoll_bone_parent( struct player_model *mdl, u32 bone_id ) +VG_STATIC u32 ragdoll_bone_parent( struct player_ragdoll *rd, + struct player_avatar *av, u32 bone_id ) { - for( u32 j=0; jragdoll_count; j++ ) - if( mdl->ragdoll[ j ].bone_id == bone_id ) + for( u32 j=0; jpart_count; j++ ) + if( rd->parts[ j ].bone_id == bone_id ) return j; vg_fatal_exit_loop( "Referenced parent bone does not have a rigidbody" ); @@ -96,24 +131,20 @@ VG_STATIC u32 ragdoll_bone_parent( struct player_model *mdl, u32 bone_id ) /* * Setup ragdoll colliders */ -VG_STATIC void player_init_ragdoll(void) +VG_STATIC void player_setup_ragdoll_from_avatar( struct player_ragdoll *rd, + struct player_avatar *av ) { - struct player_model *mdl = &player.mdl; - mdl_context *src = &mdl->meta; + rd->part_count = 0; - if( !mdl->sk.collider_count ) - { - mdl->ragdoll_count = 0; + if( !av->sk.collider_count ) return; - } - mdl->ragdoll_count = 0; - mdl->position_constraints_count = 0; - mdl->cone_constraints_count = 0; + rd->position_constraints_count = 0; + rd->cone_constraints_count = 0; - for( u32 i=0; isk.bone_count; i ++ ) + for( u32 i=0; isk.bone_count; i ++ ) { - struct skeleton_bone *bone = &mdl->sk.bones[i]; + struct skeleton_bone *bone = &av->sk.bones[i]; /* * Bones with colliders @@ -121,17 +152,17 @@ VG_STATIC void player_init_ragdoll(void) if( !(bone->flags & k_bone_flag_collider_any) ) continue; - if( mdl->ragdoll_count > vg_list_size(player.mdl.ragdoll) ) + if( rd->part_count > vg_list_size(rd->parts) ) vg_fatal_exit_loop( "Playermodel has too many colliders" ); - struct ragdoll_part *rp = &mdl->ragdoll[ mdl->ragdoll_count ++ ]; + struct ragdoll_part *rp = &rd->parts[ rd->part_count ++ ]; rp->bone_id = i; rp->parent = 0xffffffff; player_init_ragdoll_bone_collider( bone, rp ); - struct mdl_node *pnode = mdl_node_from_id( src, bone->orig_node ); - struct classtype_bone *inf = mdl_get_entdata( src, pnode ); + struct mdl_node *pnode = mdl_node_from_id( &av->meta, bone->orig_node ); + struct classtype_bone *inf = mdl_get_entdata( &av->meta, pnode ); /* * Bones with collider and parent @@ -139,15 +170,15 @@ VG_STATIC void player_init_ragdoll(void) if( !bone->parent ) continue; - rp->parent = ragdoll_bone_parent( mdl, bone->parent ); + rp->parent = ragdoll_bone_parent( rd, av, bone->parent ); /* Always assign a point-to-point constraint */ struct rb_constr_pos *c = - &mdl->position_constraints[ mdl->position_constraints_count ++ ]; + &rd->position_constraints[ rd->position_constraints_count ++ ]; - struct skeleton_bone *bj = &mdl->sk.bones[rp->bone_id]; - struct ragdoll_part *pp = &mdl->ragdoll[rp->parent]; - struct skeleton_bone *bp = &mdl->sk.bones[pp->bone_id]; + struct skeleton_bone *bj = &av->sk.bones[rp->bone_id]; + struct ragdoll_part *pp = &rd->parts[rp->parent]; + struct skeleton_bone *bp = &av->sk.bones[pp->bone_id]; /* Convention: rba -- parent, rbb -- child */ c->rba = &pp->rb; @@ -161,7 +192,7 @@ VG_STATIC void player_init_ragdoll(void) if( inf->flags & k_bone_flag_cone_constraint ) { struct rb_constr_swingtwist *a = - &mdl->cone_constraints[ mdl->cone_constraints_count ++ ]; + &rd->cone_constraints[ rd->cone_constraints_count ++ ]; a->rba = &pp->rb; a->rbb = &rp->rb; a->conet = cosf( inf->conet )-0.0001f; @@ -189,47 +220,46 @@ VG_STATIC void player_init_ragdoll(void) } /* - * Make the player model copy the ragdoll + * Make avatar copy the ragdoll */ -VG_STATIC void player_model_copy_ragdoll(void) +VG_STATIC void copy_ragdoll_pose_to_avatar( struct player_ragdoll *rd, + struct player_avatar *av ) { - struct player_model *mdl = &player.mdl; - - for( int i=0; iragdoll_count; i++ ) + for( int i=0; ipart_count; i++ ) { - struct ragdoll_part *part = &mdl->ragdoll[i]; + struct ragdoll_part *part = &rd->parts[i]; m4x3f offset; m3x3_identity(offset); m4x3_mul( part->rb.to_world, part->inv_collider_mtx, - mdl->sk.final_mtx[part->bone_id] ); + av->sk.final_mtx[part->bone_id] ); } - skeleton_apply_inverses( &mdl->sk ); + skeleton_apply_inverses( &av->sk ); } /* * Make the ragdoll copy the player model */ -VG_STATIC void player_ragdoll_copy_model( v3f v ) +VG_STATIC void copy_avatar_pose_to_ragdoll( struct player_avatar *av, + struct player_ragdoll *rd, + v3f velocity ) { - struct player_model *mdl = &player.mdl; - - for( int i=0; iragdoll_count; i++ ) + for( int i=0; ipart_count; i++ ) { - struct ragdoll_part *part = &mdl->ragdoll[i]; + struct ragdoll_part *part = &rd->parts[i]; v3f pos, offset; u32 bone = part->bone_id; - m4x3_mulv( mdl->sk.final_mtx[bone], mdl->sk.bones[bone].co, pos ); - m3x3_mulv( mdl->sk.final_mtx[bone], part->collider_mtx[3], offset ); + m4x3_mulv( av->sk.final_mtx[bone], av->sk.bones[bone].co, pos ); + m3x3_mulv( av->sk.final_mtx[bone], part->collider_mtx[3], offset ); v3_add( pos, offset, part->rb.co ); m3x3f r; - m3x3_mul( mdl->sk.final_mtx[bone], part->collider_mtx, r ); + m3x3_mul( av->sk.final_mtx[bone], part->collider_mtx, r ); m3x3_q( r, part->rb.q ); - v3_copy( v, part->rb.v ); + v3_copy( velocity, part->rb.v ); v3_zero( part->rb.w ); rb_update_transform( &part->rb ); @@ -241,16 +271,13 @@ VG_STATIC void player_ragdoll_copy_model( v3f v ) */ VG_STATIC void player_debug_ragdoll(void) { - struct player_model *mdl = &player.mdl; } /* * Ragdoll physics step */ -VG_STATIC void player_ragdoll_iter(void) +VG_STATIC void player_ragdoll_iter( struct player_ragdoll *rd ) { - struct player_model *mdl = &player.mdl; - int run_sim = 0; ragdoll_frame ++; @@ -261,25 +288,24 @@ VG_STATIC void player_ragdoll_iter(void) } rb_solver_reset(); - for( int i=0; iragdoll_count; i ++ ) - rb_collide( &mdl->ragdoll[i].rb, &world.rb_geo ); + for( int i=0; ipart_count; i ++ ) + rb_collide( &rd->parts[i].rb, &world.rb_geo ); /* * COLLISION DETECTION */ - for( int i=0; iragdoll_count-1; i ++ ) + for( int i=0; ipart_count-1; i ++ ) { - for( int j=i+1; jragdoll_count; j ++ ) + for( int j=i+1; jpart_count; j ++ ) { - if( mdl->ragdoll[j].parent != i ) - rb_collide( &mdl->ragdoll[i].rb, &mdl->ragdoll[j].rb ); + if( rd->parts[j].parent != i ) + rb_collide( &rd->parts[i].rb, &rd->parts[j].rb ); } } - for( int j=0; jragdoll_count; j++ ) + for( int j=0; jpart_count; j++ ) { - struct ragdoll_part *pj = &mdl->ragdoll[j]; - struct skeleton_bone *bj = &mdl->sk.bones[pj->bone_id]; + struct ragdoll_part *pj = &rd->parts[j]; if( run_sim ) { @@ -293,25 +319,25 @@ VG_STATIC void player_ragdoll_iter(void) * PRESOLVE */ rb_presolve_contacts( rb_contact_buffer, rb_contact_count ); - rb_presolve_swingtwist_constraints( mdl->cone_constraints, - mdl->cone_constraints_count ); + rb_presolve_swingtwist_constraints( rd->cone_constraints, + rd->cone_constraints_count ); /* * DEBUG */ if( k_ragdoll_debug_collider ) { - for( u32 i=0; iragdoll_count; i ++ ) - rb_debug( &mdl->ragdoll[i].rb, mdl->ragdoll[i].colour ); + for( u32 i=0; ipart_count; i ++ ) + rb_debug( &rd->parts[i].rb, rd->parts[i].colour ); } if( k_ragdoll_debug_constraints ) { - rb_debug_position_constraints( mdl->position_constraints, - mdl->position_constraints_count ); + rb_debug_position_constraints( rd->position_constraints, + rd->position_constraints_count ); - rb_debug_swingtwist_constraints( mdl->cone_constraints, - mdl->cone_constraints_count ); + rb_debug_swingtwist_constraints( rd->cone_constraints, + rd->cone_constraints_count ); } /* @@ -322,23 +348,23 @@ VG_STATIC void player_ragdoll_iter(void) for( int i=0; i<25; i++ ) { rb_solve_contacts( rb_contact_buffer, rb_contact_count ); - rb_solve_swingtwist_constraints( mdl->cone_constraints, - mdl->cone_constraints_count ); - rb_solve_position_constraints( mdl->position_constraints, - mdl->position_constraints_count ); + rb_solve_swingtwist_constraints( rd->cone_constraints, + rd->cone_constraints_count ); + rb_solve_position_constraints( rd->position_constraints, + rd->position_constraints_count ); } - for( int i=0; iragdoll_count; i++ ) - rb_iter( &mdl->ragdoll[i].rb ); + for( int i=0; ipart_count; i++ ) + rb_iter( &rd->parts[i].rb ); - for( int i=0; iragdoll_count; i++ ) - rb_update_transform( &mdl->ragdoll[i].rb ); + for( int i=0; ipart_count; i++ ) + rb_update_transform( &rd->parts[i].rb ); - rb_correct_swingtwist_constraints( mdl->cone_constraints, - mdl->cone_constraints_count, 0.25f ); + rb_correct_swingtwist_constraints( rd->cone_constraints, + rd->cone_constraints_count, 0.25f ); - rb_correct_position_constraints( mdl->position_constraints, - mdl->position_constraints_count, 0.5f ); + rb_correct_position_constraints( rd->position_constraints, + rd->position_constraints_count, 0.5f ); } } diff --git a/skaterift.c b/skaterift.c index ab24550..be5d4d6 100644 --- a/skaterift.c +++ b/skaterift.c @@ -26,8 +26,11 @@ #include "player_device_walk.h" #include "player_model.h" +/* temp */ VG_STATIC player_interface localplayer; VG_STATIC struct player_device_walk localplayer_walk; +VG_STATIC struct player_avatar localplayer_avatar; +VG_STATIC glmesh localplayer_meshes[3]; #endif @@ -166,6 +169,50 @@ vg_info(" ' ' '--' [] '----- '----- ' ' '---' " vg_loader_step( network_init, network_end ); } +VG_STATIC void load_playermodels(void) +{ + vg_linear_clear( vg_mem.scratch ); + + /* + * load in other player models. This may need to be more sophisticated in + * the futre if we have more of these guys + */ + mdl_context ctx_default, + ctx_outlaw, + ctx_jordan; + + mdl_open( &ctx_default, "models/ch_new.mdl" ); + mdl_load_metadata( &ctx_default, vg_mem.scratch ); + mdl_load_mesh_data( &ctx_default, vg_mem.scratch ); + mdl_close( &ctx_default ); + + mdl_open( &ctx_outlaw, "models/ch_outlaw.mdl" ); + mdl_load_metadata( &ctx_outlaw, vg_mem.scratch ); + mdl_load_mesh_data( &ctx_outlaw, vg_mem.scratch ); + mdl_close( &ctx_outlaw ); + + mdl_open( &ctx_jordan, "models/ch_jordan.mdl" ); + mdl_load_metadata( &ctx_jordan, vg_mem.scratch ); + mdl_load_mesh_data( &ctx_jordan, vg_mem.scratch ); + mdl_close( &ctx_jordan ); + + vg_acquire_thread_sync(); + { + mdl_unpack_glmesh( &ctx_default, &localplayer_meshes[0] ); + mdl_unpack_glmesh( &ctx_outlaw, &localplayer_meshes[1] ); + mdl_unpack_glmesh( &ctx_jordan, &localplayer_meshes[2] ); + } + vg_release_thread_sync(); + + /* FIXME: hack */ + shader_viewchar_register(); + vg_acquire_thread_sync(); + { + vg_tex2d_init( (vg_tex2d *[]){ &tex_characters }, 1 ); + } + vg_release_thread_sync(); +} + VG_STATIC void vg_load(void) { vg_loader_step( render_init, NULL ); @@ -174,11 +221,21 @@ VG_STATIC void vg_load(void) //vg_loader_step( player_init, NULL ); //vg_loader_step( vehicle_init, NULL ); // - vg_loader_step( player_model_init, NULL ); - + //vg_loader_step( player_model_init, NULL ); + + /* ----------------- */ + vg_loader_step( load_playermodels, NULL ); + + /* player setup */ player_interface_create_player( &localplayer ); + + player_avatar_load( &localplayer_avatar, "models/ch_new.mdl" ); + player_use_avatar( &localplayer, &localplayer_avatar ); + player_use_mesh( &localplayer, &localplayer_meshes[0] ); player_use_device( &localplayer, &player_device_walk, &localplayer_walk ); + /* --------------------- */ + vg_bake_shaders(); vg_loader_step( audio_init, audio_free ); world_audio_init(); @@ -321,41 +378,36 @@ VG_STATIC void render_player_transparent(void) camera_finalize( &small_cam ); /* Draw player to window buffer and blend background ontop */ - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); -#if 0 - draw_player( &small_cam ); -#endif + player_render( &small_cam, &localplayer ); } VG_STATIC void render_scene(void) { render_fb_bind( gpipeline.fb_main ); glClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); - glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); + glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT ); /* Draw world */ glEnable( GL_DEPTH_TEST ); render_world( &main_camera ); -#if 0 - int player_transparent = !(player.is_dead || freecam), - player_draw = !cl_menu; + + + int player_transparent = 1, + player_draw = 1; if( !player_transparent && player_draw ) - draw_player( &main_camera ); -#endif + player_render( &main_camera, &localplayer ); render_water_texture( &main_camera ); render_fb_bind( gpipeline.fb_main ); render_water_surface( &main_camera ); render_world_gates( &main_camera ); -#if 0 if( player_transparent && player_draw ) render_player_transparent(); -#endif } VG_STATIC void render_menu(void) @@ -386,6 +438,9 @@ VG_STATIC void render_main_game(void) /* copy camera from player. * TODO: blend with camera from menu */ + /* FIXME: TEMP!! */ + player_pre_render( &localplayer ); + v3_copy( localplayer.cam.pos, main_camera.pos ); v3_copy( localplayer.cam.angles, main_camera.angles ); main_camera.fov = localplayer.cam.fov; diff --git a/skeleton.h b/skeleton.h index 4f35d58..ad87fd9 100644 --- a/skeleton.h +++ b/skeleton.h @@ -61,6 +61,9 @@ VG_STATIC u32 skeleton_bone_id( struct skeleton *skele, const char *name ) return i; } + vg_error( "skeleton_bone_id( *, \"%s\" );\n", name ); + vg_fatal_exit_loop( "Bone does not exist\n" ); + return 0; } @@ -376,7 +379,7 @@ VG_STATIC void skeleton_apply_standard( struct skeleton *skele, mdl_keyframe *po * Get an animation by name */ VG_STATIC struct skeleton_anim *skeleton_get_anim( struct skeleton *skele, - const char *name ) + const char *name ) { for( int i=0; ianim_count; i++ ) { @@ -386,6 +389,9 @@ VG_STATIC struct skeleton_anim *skeleton_get_anim( struct skeleton *skele, return anim; } + vg_error( "skeleton_get_anim( *, \"%s\" )\n", name ); + vg_fatal_exit_loop( "Invalid animation name\n" ); + return NULL; } -- 2.25.1