#define PLAYER_DEVICE_WALK_H
#include "player_interface.h"
+#include "skeleton.h"
+#include "player_model.h"
VG_STATIC float
k_walkspeed = 10.0f,
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,
if( v2_length2(walk) > 0.001f )
v2_normalize_clamp( walk );
+ w->move_speed = v2_length( walk );
+
/*
* Collision detection
*/
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 );
}
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,
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 */
#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;
*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 );
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 )
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 );
}
#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 ];
{
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];
#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();
}
}
}
+#endif
#endif
#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,
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 )
{
/*
* 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; j<mdl->ragdoll_count; j++ )
- if( mdl->ragdoll[ j ].bone_id == bone_id )
+ for( u32 j=0; j<rd->part_count; j++ )
+ if( rd->parts[ j ].bone_id == bone_id )
return j;
vg_fatal_exit_loop( "Referenced parent bone does not have a rigidbody" );
/*
* 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; i<mdl->sk.bone_count; i ++ )
+ for( u32 i=0; i<av->sk.bone_count; i ++ )
{
- struct skeleton_bone *bone = &mdl->sk.bones[i];
+ struct skeleton_bone *bone = &av->sk.bones[i];
/*
* Bones with colliders
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
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;
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;
}
/*
- * 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; i<mdl->ragdoll_count; i++ )
+ for( int i=0; i<rd->part_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; i<mdl->ragdoll_count; i++ )
+ for( int i=0; i<rd->part_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 );
*/
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 ++;
}
rb_solver_reset();
- for( int i=0; i<mdl->ragdoll_count; i ++ )
- rb_collide( &mdl->ragdoll[i].rb, &world.rb_geo );
+ for( int i=0; i<rd->part_count; i ++ )
+ rb_collide( &rd->parts[i].rb, &world.rb_geo );
/*
* COLLISION DETECTION
*/
- for( int i=0; i<mdl->ragdoll_count-1; i ++ )
+ for( int i=0; i<rd->part_count-1; i ++ )
{
- for( int j=i+1; j<mdl->ragdoll_count; j ++ )
+ for( int j=i+1; j<rd->part_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; j<mdl->ragdoll_count; j++ )
+ for( int j=0; j<rd->part_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 )
{
* 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; i<mdl->ragdoll_count; i ++ )
- rb_debug( &mdl->ragdoll[i].rb, mdl->ragdoll[i].colour );
+ for( u32 i=0; i<rd->part_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 );
}
/*
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; i<mdl->ragdoll_count; i++ )
- rb_iter( &mdl->ragdoll[i].rb );
+ for( int i=0; i<rd->part_count; i++ )
+ rb_iter( &rd->parts[i].rb );
- for( int i=0; i<mdl->ragdoll_count; i++ )
- rb_update_transform( &mdl->ragdoll[i].rb );
+ for( int i=0; i<rd->part_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 );
}
}
#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
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 );
//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();
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)
/* 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;
return i;
}
+ vg_error( "skeleton_bone_id( *, \"%s\" );\n", name );
+ vg_fatal_exit_loop( "Bone does not exist\n" );
+
return 0;
}
* 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; i<skele->anim_count; i++ )
{
return anim;
}
+ vg_error( "skeleton_get_anim( *, \"%s\" )\n", name );
+ vg_fatal_exit_loop( "Invalid animation name\n" );
+
return NULL;
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff