/*
* Appearence
*/
-static void player__use_avatar( struct player_avatar *av ){
- localplayer.playeravatar = av;
- player_setup_ragdoll_from_avatar( &localplayer.ragdoll, av );
-}
static void player__use_model( u16 reg_id ){
addon_cache_unwatch( k_addon_type_player,
* --------------------------------------------------
*/
- struct player_avatar *playeravatar;
struct player_ragdoll ragdoll;
struct player_model fallback_model;
*/
enum player_subsystem subsystem; /* .. prev */
+
+ /*
+ * Rendering
+ */
+ mdl_context skeleton_meta;
+ struct skeleton skeleton;
+
+ u32 id_hip,
+ id_chest,
+ 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_ik_knee_l,
+ id_ik_knee_r,
+ id_wheel_l,
+ id_wheel_r,
+ id_board;
}
static localplayer = {
.rb = {
*/
static void player__debugtext( int size, const char *fmt, ... );
-static void player__use_avatar( struct player_avatar *av );
static void player__use_mesh( glmesh *mesh );
static void player__use_texture( vg_tex2d *tex );
static void player__use_model( u16 reg_id );
m4x3_invert_affine( localplayer.gate_waiting->transport, inverse );
m4x3_mulv( inverse, localplayer.cam.pos, localplayer.cam.pos );
- struct skeleton *sk = &localplayer.playeravatar->sk;
- skeleton_apply_transform( sk, inverse, localplayer.final_mtx );
+ skeleton_apply_transform( &localplayer.skeleton, inverse,
+ localplayer.final_mtx );
}
}
}
static void player__cam_iterate(void){
- struct player_avatar *av = localplayer.playeravatar;
struct player_cam_controller *cc = &localplayer.cam_control;
if( localplayer.subsystem == k_player_subsystem_walk ){
/* position */
v3f fpv_pos, fpv_offset;
- m4x3_mulv( localplayer.final_mtx[ av->id_head-1 ],
+ m4x3_mulv( localplayer.final_mtx[ localplayer.id_head-1 ],
cc->fpv_viewpoint_smooth, fpv_pos );
m3x3_mulv( localplayer.rb.to_world, cc->fpv_offset_smooth, fpv_offset );
v3_add( fpv_offset, fpv_pos, fpv_pos );
}
static void player__dead_post_update(void){
- struct player_avatar *av = localplayer.playeravatar;
- struct ragdoll_part *part = &localplayer.ragdoll.parts[ av->id_hip-1 ];
+ struct ragdoll_part *part =
+ &localplayer.ragdoll.parts[ localplayer.id_hip-1 ];
struct player_dead *d = &player_dead;
v3f ext_co;
struct player_dead *d = &player_dead;
struct player_dead_animator *animator = &d->animator;
struct player_ragdoll *rd = &localplayer.ragdoll;
- struct player_avatar *av = localplayer.playeravatar;
- struct skeleton *sk = &av->sk;
+ struct skeleton *sk = &localplayer.skeleton;
m4x3f transforms[ 32 ];
static void player__dead_pose( void *_animator, player_pose *pose ){
struct player_dead_animator *animator = _animator;
struct player_ragdoll *rd = &localplayer.ragdoll;
- struct player_avatar *av = localplayer.playeravatar;
- struct skeleton *sk = &av->sk;
+ struct skeleton *sk = &localplayer.skeleton;
pose->type = k_player_pose_type_fk_2;
pose->board.lean = 0.0f;
static void player__dead_transition(void){
localplayer.subsystem = k_player_subsystem_dead;
- copy_avatar_pose_to_ragdoll( localplayer.playeravatar, &localplayer.ragdoll,
- localplayer.rb.v );
+ copy_localplayer_to_ragdoll( &localplayer.ragdoll, localplayer.rb.v );
- struct player_avatar *av = localplayer.playeravatar;
- struct ragdoll_part *part = &localplayer.ragdoll.parts[ av->id_hip-1 ];
+ struct ragdoll_part *part =
+ &localplayer.ragdoll.parts[ localplayer.id_hip-1 ];
v3_copy( part->obj.rb.co, player_dead.co_lpf );
v3_copy( part->obj.rb.v, player_dead.v_lpf );
v3_copy( part->obj.rb.w, player_dead.w_lpf );
static void player__dead_animator_exchange( bitpack_ctx *ctx, void *data ){
struct player_dead_animator *animator = data;
- for( u32 i=0; i<localplayer.playeravatar->sk.bone_count; i ++ ){
+ for( u32 i=0; i<localplayer.skeleton.bone_count; i ++ ){
bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->transforms[i].co );
bitpack_qquat( ctx, animator->transforms[i].q );
}
static void player__drive_animate(void){}
static void player__drive_pose( void *animator, player_pose *pose ){
- struct skeleton *sk = &localplayer.playeravatar->sk;
+ struct skeleton *sk = &localplayer.skeleton;
skeleton_sample_anim( sk, player_drive.anim_drive, 0.0f, pose->keyframes );
v3_copy( localplayer.rb.co, pose->root_co );
}
static void player__drive_bind(void){
- struct player_avatar *av = localplayer.playeravatar;
- struct skeleton *sk = &av->sk;
-
+ struct skeleton *sk = &localplayer.skeleton;
player_drive.vehicle = &gzoomer;
player_drive.anim_drive = skeleton_get_anim( sk, "idle_cycle+y" );
}
/*
* Get parent index in the ragdoll
*/
-static u32 ragdoll_bone_parent( struct player_ragdoll *rd,
- struct player_avatar *av, u32 bone_id )
-{
+static u32 ragdoll_bone_parent( struct player_ragdoll *rd, u32 bone_id ){
for( u32 j=0; j<rd->part_count; j++ )
if( rd->parts[ j ].bone_id == bone_id )
return j;
}
/*
- * Setup ragdoll colliders
+ * Setup ragdoll colliders from skeleton
*/
-static void player_setup_ragdoll_from_avatar( struct player_ragdoll *rd,
- struct player_avatar *av )
-{
+static void setup_ragdoll_from_skeleton( struct skeleton *sk,
+ struct player_ragdoll *rd ){
rd->part_count = 0;
- if( !av->sk.collider_count )
+ if( !sk->collider_count )
return;
rd->position_constraints_count = 0;
rd->cone_constraints_count = 0;
- for( u32 i=1; i<av->sk.bone_count; i ++ ){
- struct skeleton_bone *bone = &av->sk.bones[i];
+ for( u32 i=1; i<sk->bone_count; i ++ ){
+ struct skeleton_bone *bone = &sk->bones[i];
/*
* Bones with colliders
if( !bone->parent )
continue;
- rp->parent = ragdoll_bone_parent( rd, av, bone->parent );
-
+ rp->parent = ragdoll_bone_parent( rd, bone->parent );
if( bone->orig_bone->flags & k_bone_flag_cone_constraint ){
struct rb_constr_pos *c =
&rd->position_constraints[ rd->position_constraints_count ++ ];
- struct skeleton_bone *bj = &av->sk.bones[rp->bone_id];
+ struct skeleton_bone *bj = &sk->bones[rp->bone_id];
struct ragdoll_part *pp = &rd->parts[rp->parent];
- struct skeleton_bone *bp = &av->sk.bones[pp->bone_id];
+ struct skeleton_bone *bp = &sk->bones[pp->bone_id];
/* Convention: rba -- parent, rbb -- child */
c->rba = &pp->obj.rb;
/*
* Make avatar copy the ragdoll
*/
-static void copy_ragdoll_pose_to_avatar( struct player_ragdoll *rd,
- struct player_avatar *av )
-{
+static void copy_ragdoll_pose_to_localplayer( struct player_ragdoll *rd ){
for( int i=0; i<rd->part_count; i++ ){
struct ragdoll_part *part = &rd->parts[i];
localplayer.final_mtx[part->bone_id] );
}
- for( u32 i=1; i<av->sk.bone_count; i++ ){
- struct skeleton_bone *sb = &av->sk.bones[i];
+ for( u32 i=1; i<localplayer.skeleton.bone_count; i++ ){
+ struct skeleton_bone *sb = &localplayer.skeleton.bones[i];
if( sb->parent && !sb->collider ){
v3f delta;
- v3_sub( av->sk.bones[i].co, av->sk.bones[sb->parent].co, delta );
+ v3_sub( localplayer.skeleton.bones[i].co,
+ localplayer.skeleton.bones[sb->parent].co, delta );
m4x3f posemtx;
m3x3_identity( posemtx );
}
}
- skeleton_apply_inverses( &av->sk, localplayer.final_mtx );
+ skeleton_apply_inverses( &localplayer.skeleton, localplayer.final_mtx );
}
/*
* Make the ragdoll copy the player model
*/
-static void copy_avatar_pose_to_ragdoll( struct player_avatar *av,
- struct player_ragdoll *rd,
- v3f velocity )
-{
+static void copy_localplayer_to_ragdoll( struct player_ragdoll *rd, v3f v ){
for( int i=0; i<rd->part_count; i++ ){
struct ragdoll_part *part = &rd->parts[i];
v3f pos, offset;
u32 bone = part->bone_id;
+ v3f *bone_mtx = localplayer.final_mtx[bone];
- m4x3_mulv( localplayer.final_mtx[bone], av->sk.bones[bone].co, pos );
- m3x3_mulv( localplayer.final_mtx[bone], part->collider_mtx[3], offset );
+ m4x3_mulv( bone_mtx, localplayer.skeleton.bones[bone].co, pos );
+ m3x3_mulv( bone_mtx, part->collider_mtx[3], offset );
v3_add( pos, offset, part->obj.rb.co );
m3x3f r;
- m3x3_mul( localplayer.final_mtx[bone], part->collider_mtx, r );
+ m3x3_mul( bone_mtx, part->collider_mtx, r );
m3x3_q( r, part->obj.rb.q );
- v3_copy( velocity, part->obj.rb.v );
+ v3_copy( v, part->obj.rb.v );
v3_zero( part->obj.rb.w );
v3_copy( part->obj.rb.co, part->prev_co );
}
}
-/*
- * Draw rigidbody colliders for ragdoll
- */
-static void player_debug_ragdoll(void)
-{
-}
-
/*
* Ragdoll physics step
*/
static void player_ragdoll_init(void);
static void player_init_ragdoll_bone_collider( struct skeleton_bone *bone,
struct ragdoll_part *rp );
-static u32 ragdoll_bone_parent( struct player_ragdoll *rd,
- struct player_avatar *av, u32 bone_id );
-static void player_setup_ragdoll_from_avatar( struct player_ragdoll *rd,
- struct player_avatar *av );
-static void copy_ragdoll_pose_to_avatar( struct player_ragdoll *rd,
- struct player_avatar *av );
-static void copy_avatar_pose_to_ragdoll( struct player_avatar *av,
- struct player_ragdoll *rd,
- v3f velocity );
+static u32 ragdoll_bone_parent( struct player_ragdoll *rd, u32 bone_id );
+static void setup_ragdoll_from_skeleton( struct skeleton *sk,
+ struct player_ragdoll *rd );
+static void copy_ragdoll_pose_to_localplayer( struct player_ragdoll *rd );
+static void copy_localplayer_to_ragdoll( struct player_ragdoll *rd, v3f v );
static void player_debug_ragdoll(void);
static void player_ragdoll_iter( struct player_ragdoll *rd );
}
static void remote_player_nametag( m4x4f pv, v3f co, const char *name ){
- return;
vg_ui.font = &vg_ui_font_big;
v4f wpos;
v3_copy( co, wpos );
wr[0] = vg_clampf(wpos[0] * vg.window_x, -32000.0f,32000.0f)-150;
wr[1] = vg_clampf((1.0f-wpos[1]) * vg.window_y,
-32000.0f,32000.0f);
- wr[2] = 300;
+
+ vg_ui.font = &vg_ui_font_big;
+ wr[2] = ui_text_line_width( name );
wr[3] = 32;
- ui_fill( wr, (ui_colour(k_ui_bg)&0x00ffffff)|0x50000000 );
+
+ ui_fill( wr, ui_opacity( ui_colour(k_ui_bg), 0.6f ) );
ui_text( wr, name, 1, k_ui_align_middle_center, 0 );
+
+ vg_ui.font = &vg_ui_font_small;
+
}
vg_ui.font = &vg_ui_font_small;
}
snprintf( buf, 512, "#%u: %s [%s] D%.1fkbs",
i, player->username, sysname, player->down_kbs );
ui_info( panel, buf );
-
- struct player_avatar *av = localplayer.playeravatar;
- remote_player_nametag(
- pv,
- netplayers.final_mtx[av->sk.bone_count*i][3],
- player->username );
}
}
}
else {
ui_info( panel, "offline" );
}
-
- struct player_avatar *av = localplayer.playeravatar;
- remote_player_nametag(
- pv,
- localplayer.final_mtx[0][3],
- "Localplayer" );
}
/*
struct network_player *player = &netplayers.list[ index ];
struct interp_buffer *buf = &netplayers.interp_data[ index ];
- struct player_avatar *av = localplayer.playeravatar;
- m4x3f *final_mtx = &netplayers.final_mtx[ av->sk.bone_count*index ];
+ struct skeleton *sk = &localplayer.skeleton;
+ m4x3f *final_mtx = &netplayers.final_mtx[ sk->bone_count*index ];
struct player_board_pose *board_pose = &netplayers.board_poses[index];
struct player_subsystem_interface *sys0 = player_subsystems[f0->subsystem],
instance_id = f1->instance_id;
lerp_player_pose( &pose0, &pose1, t, &posed );
- apply_full_skeleton_pose( &av->sk, &posed, final_mtx );
+ apply_full_skeleton_pose( sk, &posed, final_mtx );
memcpy( board_pose, &posed.board, sizeof(*board_pose) );
}
else {
instance_id = f0->instance_id;
- apply_full_skeleton_pose( &av->sk, &pose0, final_mtx );
+ apply_full_skeleton_pose( sk, &pose0, final_mtx );
memcpy( board_pose, &pose0.board, sizeof(*board_pose) );
}
*/
static void render_remote_players( world_instance *world, camera *cam ){
SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+ struct skeleton *sk = &localplayer.skeleton;
for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
struct network_player *player = &netplayers.list[i];
if( !player->active || player->isblocked ) continue;
if( player->active_world != world ) continue;
- struct player_avatar *av = localplayer.playeravatar;
- m4x3f *final_mtx = &netplayers.final_mtx[ av->sk.bone_count*i ];
+ m4x3f *final_mtx = &netplayers.final_mtx[ sk->bone_count*i ];
struct player_model *model =
addon_cache_item_if_loaded( k_addon_type_player,
player->playermodel_view_slot );
if( !model ) model = &localplayer.fallback_model;
- render_playermodel( cam, world, 0, model, &av->sk, final_mtx );
+ render_playermodel( cam, world, 0, model, sk, final_mtx );
struct player_board *board =
addon_cache_item_if_loaded( k_addon_type_board,
player->board_view_slot );
- render_board( cam, world, board,
- final_mtx[localplayer.playeravatar->id_board],
- &netplayers.board_poses[ i ],
- k_board_shader_player );
+ render_board( cam, world, board, final_mtx[localplayer.id_board],
+ &netplayers.board_poses[ i ], k_board_shader_player );
}
SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
if( !player->active || player->isblocked ) continue;
if( player->active_world != world ) continue;
- struct player_avatar *av = localplayer.playeravatar;
render_remote_player_nametag(
- netplayers.final_mtx[av->sk.bone_count*i][3],
+ netplayers.final_mtx[localplayer.skeleton.bone_count*i][3],
player->username );
}
glDisable(GL_BLEND);
}
+static int remote_players_randomize( int argc, const char *argv[] ){
+ for( int i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
+ struct network_player *player = &netplayers.list[i];
+
+ player->active = vg_randu32() & 0x1;
+ player->isfriend = vg_randu32() & vg_randu32() & 0x1;
+ player->isblocked = vg_randu32() & vg_randu32() & vg_randu32() & 0x1;
+ player->world_match[ 0 ] = vg_randu32() & 0x1;
+ player->world_match[ 1 ] = 0;
+
+ for( int i=0; i<sizeof(player->username)-1; i ++ ){
+ player->username[i] = 'a' + (vg_randu32() % 30);
+ player->username[i+1] = '\0';
+
+ if( (vg_randu32() % 8) == 3 )
+ break;
+ }
+ }
+
+ return 0;
+}
+
static void remote_players_init(void){
+ vg_console_reg_cmd( "add_test_players", remote_players_randomize, NULL );
vg_console_reg_var( "k_show_own_name", &k_show_own_name,
k_var_dtype_i32, 0 );
for( u32 i=0; i<NETWORK_SFX_QUEUE_LENGTH; i ++ ){
enum remote_player_gui_type {
k_remote_player_gui_type_stranger,
+ k_remote_player_gui_type_friend,
k_remote_player_gui_type_you,
- k_remote_player_gui_type_friend
};
static void remote_player_gui_info( ui_rect box,
ui_text( bottom, activity, 1, k_ui_align_middle_center, fg );
}
-static void remote_players_imgui(void){
- /* TODO: or if respawning, override show this and disable input
- * if in menu dont render. */
-
- if( button_down(k_srbind_lobby) )
- netplayers.view_lobby ^= 0x1;
-
- vg_slewf( &netplayers.fview_lobby, netplayers.view_lobby,
- vg.time_frame_delta / 0.5f );
+static void remote_players_imgui_lobby(void){
+ /*
+ * TODO: send location string over the network */
ui_px y = 50, width = 200, height = 42, gap = 2,
- x = vg.window_x - ((f32)width*netplayers.fview_lobby);
-
- int type = vg.time,
- in_world = vg.time / 3.0;
-
+ x = vg.window_x - width;
vg_ui.font = &vg_ui_font_big;
ui_text( (ui_rect){ x, 0, width, height },
- "In World", 1, k_ui_align_middle_center, 0 );
+ "Online Players", 1, k_ui_align_middle_center, 0 );
vg_ui.font = &vg_ui_font_small;
ui_rect us = { x, y, width, height };
- remote_player_gui_info( us, steam_username_at_startup, "1300 meters away",
- type % 3, in_world % 2 );
+ /* FIXME: your location */
+ remote_player_gui_info( us, steam_username_at_startup, "you",
+ k_remote_player_gui_type_you, 1 );
y += height + gap;
for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
struct network_player *player = &netplayers.list[i];
- if( !player->active || !player->isfriend ) continue;
+ if( !player->active || player->isblocked ) continue;
ui_rect box = { x, y, width, height };
- remote_player_gui_info( box, player->username, "", 0, 0 );
+ remote_player_gui_info(
+ box, player->username, "<null>",
+ player->isfriend,
+ player->world_match[ world_static.active_instance ] );
y += height + gap;
}
}
+
+static void remote_players_imgui_world( world_instance *world, m4x4f pv,
+ f32 max_dist ){
+ for( u32 i=0; i<NETWORK_MAX_PLAYERS; i++ ){
+ struct network_player *player = &netplayers.list[i];
+ if( player->active ){
+ remote_player_nametag(
+ pv,
+ netplayers.final_mtx[localplayer.skeleton.bone_count*i][3],
+ player->username );
+ }
+ }
+}
/* this is set IF they exist in a world that we have loaded */
world_instance *active_world;
int world_match[ k_world_max ];
+ u32 location_pstr; /* TODO: valid if active_world set. */
/* TODO: Compression with server code */
char username[ NETWORK_USERNAME_MAX ];
u32 up_bytes;
f32 up_kbs, down_kbs;
f64 last_data_measurement;
-
- int view_lobby;
- f32 fview_lobby;
}
static netplayers;
#include "shaders/model_board_view.h"
#include "depth_compare.h"
-static void player_avatar_load( struct player_avatar *av, const char *path ){
- mdl_open( &av->meta, path, vg_mem.rtmemory );
- mdl_load_metadata_block( &av->meta, vg_mem.rtmemory );
- mdl_load_animation_block( &av->meta, vg_mem.rtmemory );
- mdl_close( &av->meta );
-
- struct skeleton *sk = &av->sk;
- skeleton_setup( sk, vg_mem.rtmemory, &av->meta );
-
- av->id_hip = skeleton_bone_id( sk, "hips" );
- av->id_chest = skeleton_bone_id( sk, "chest" );
- 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" );
- av->id_wheel_l = skeleton_bone_id( sk, "wheel.L" );
- av->id_wheel_r = skeleton_bone_id( sk, "wheel.R" );
- av->id_ik_knee_l = skeleton_bone_id( sk, "knee.L" );
- av->id_ik_knee_r = skeleton_bone_id( sk, "knee.R" );
+static void player_load_animation_reference( const char *path ){
+ mdl_context *meta = &localplayer.skeleton_meta;
+ mdl_open( meta, path, vg_mem.rtmemory );
+ mdl_load_metadata_block( meta, vg_mem.rtmemory );
+ mdl_load_animation_block( meta, vg_mem.rtmemory );
+ mdl_close( meta );
+
+ struct skeleton *sk = &localplayer.skeleton;
+ skeleton_setup( sk, vg_mem.rtmemory, meta );
+
+ localplayer.id_hip = skeleton_bone_id( sk, "hips" );
+ localplayer.id_chest = skeleton_bone_id( sk, "chest" );
+ localplayer.id_ik_hand_l = skeleton_bone_id( sk, "hand.IK.L" );
+ localplayer.id_ik_hand_r = skeleton_bone_id( sk, "hand.IK.R" );
+ localplayer.id_ik_elbow_l = skeleton_bone_id( sk, "elbow.L" );
+ localplayer.id_ik_elbow_r = skeleton_bone_id( sk, "elbow.R" );
+ localplayer.id_head = skeleton_bone_id( sk, "head" );
+ localplayer.id_ik_foot_l = skeleton_bone_id( sk, "foot.IK.L" );
+ localplayer.id_ik_foot_r = skeleton_bone_id( sk, "foot.IK.R" );
+ localplayer.id_board = skeleton_bone_id( sk, "board" );
+ localplayer.id_wheel_l = skeleton_bone_id( sk, "wheel.L" );
+ localplayer.id_wheel_r = skeleton_bone_id( sk, "wheel.R" );
+ localplayer.id_ik_knee_l = skeleton_bone_id( sk, "knee.L" );
+ localplayer.id_ik_knee_r = skeleton_bone_id( sk, "knee.R" );
+
+ setup_ragdoll_from_skeleton( sk, &localplayer.ragdoll );
+
+ /* allocate matrix buffers for localplayer and remote players */
+ u32 mtx_size = sizeof(m4x3f)*sk->bone_count;
+ localplayer.final_mtx = vg_linear_alloc( vg_mem.rtmemory, mtx_size );
+ netplayers.final_mtx = vg_linear_alloc( vg_mem.rtmemory,
+ mtx_size*NETWORK_MAX_PLAYERS );
}
/* TODO: Standard model load */
player_pose *pose = &localplayer.pose;
sys->pose( sys->animator_data, pose );
- struct skeleton *sk = &localplayer.playeravatar->sk;
+ struct skeleton *sk = &localplayer.skeleton;
if( localplayer.holdout_time > 0.0f ){
skeleton_lerp_pose( sk,
localplayer.holdout_time -= vg.time_frame_delta * 2.0f;
}
- apply_full_skeleton_pose( &localplayer.playeravatar->sk, &localplayer.pose,
- localplayer.final_mtx );
+ apply_full_skeleton_pose( sk, &localplayer.pose, localplayer.final_mtx );
skeleton_debug( sk, localplayer.final_mtx );
if( sys->post_animate )
static void lerp_player_pose( player_pose *pose0, player_pose *pose1, f32 t,
player_pose *posed ){
- struct skeleton *sk = &localplayer.playeravatar->sk;
+ struct skeleton *sk = &localplayer.skeleton;
v3_lerp( pose0->root_co, pose1->root_co, t, posed->root_co );
q_nlerp( pose0->root_q, pose1->root_q, t, posed->root_q );
}
else return;
- apply_full_skeleton_pose( &localplayer.playeravatar->sk, &localplayer.pose,
+ apply_full_skeleton_pose( &localplayer.skeleton, &localplayer.pose,
localplayer.final_mtx );
}
static void player__pre_render(void){
/* shadowing/ao info */
- struct player_avatar *av = localplayer.playeravatar;
struct player_board *board =
addon_cache_item_if_loaded( k_addon_type_board,
localplayer.board_view_slot );
}
struct ub_world_lighting *ubo = &world_current_instance()->ub_lighting;
- m4x3_mulv( localplayer.final_mtx[ av->id_board ], vp0, ubo->g_board_0 );
- m4x3_mulv( localplayer.final_mtx[ av->id_board ], vp1, ubo->g_board_1 );
+ v3f *board_mtx = localplayer.final_mtx[ localplayer.id_board ];
+ m4x3_mulv( board_mtx, vp0, ubo->g_board_0 );
+ m4x3_mulv( board_mtx, vp1, ubo->g_board_1 );
}
static void render_board( camera *cam, world_instance *world,
localplayer.playermodel_view_slot );
if( !model ) model = &localplayer.fallback_model;
- render_playermodel( cam, world, 1, model, &localplayer.playeravatar->sk,
+ render_playermodel( cam, world, 1, model, &localplayer.skeleton,
localplayer.final_mtx );
struct player_board *board =
addon_cache_item_if_loaded( k_addon_type_board,
localplayer.board_view_slot );
- render_board( cam, world, board, localplayer.final_mtx[
- localplayer.playeravatar->id_board],
- &localplayer.pose.board,
- k_board_shader_player );
+ render_board( cam, world, board, localplayer.final_mtx[localplayer.id_board],
+ &localplayer.pose.board, k_board_shader_player );
SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
}
#include "camera.h"
#include "world.h"
-struct player_avatar
-{
- mdl_context meta;
- struct skeleton sk;
-
- u32 id_hip,
- id_chest,
- 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_ik_knee_l,
- id_ik_knee_r,
- id_wheel_l,
- id_wheel_r,
- id_board;
-};
-
enum eboard_truck{
k_board_truck_back = 0,
k_board_truck_front = 1
#include "addon.h"
static void player__skate_bind(void){
- struct player_avatar *av = localplayer.playeravatar;
- struct skeleton *sk = &av->sk;
-
+ struct skeleton *sk = &localplayer.skeleton;
rb_update_transform( &localplayer.rb );
struct { struct skeleton_anim **anim; const char *name; }
}
static void player__skate_pose( void *_animator, player_pose *pose ){
- struct player_avatar *av = localplayer.playeravatar;
- struct skeleton *sk = &av->sk;
+ struct skeleton *sk = &localplayer.skeleton;
struct player_skate_animator *animator = _animator;
pose->type = k_player_pose_type_ik;
skeleton_lerp_pose( sk, ground_pose, air_pose, animator->fly,
pose->keyframes );
- mdl_keyframe *kf_board = &pose->keyframes[av->id_board-1],
- *kf_foot_l = &pose->keyframes[av->id_ik_foot_l-1],
- *kf_foot_r = &pose->keyframes[av->id_ik_foot_r-1],
- *kf_knee_l = &pose->keyframes[av->id_ik_knee_l-1],
- *kf_knee_r = &pose->keyframes[av->id_ik_knee_r-1],
- *kf_hip = &pose->keyframes[av->id_hip-1],
- *kf_wheels[] = { &pose->keyframes[av->id_wheel_r-1],
- &pose->keyframes[av->id_wheel_l-1] };
+ mdl_keyframe *kf_board = &pose->keyframes[localplayer.id_board-1],
+ *kf_foot_l = &pose->keyframes[localplayer.id_ik_foot_l-1],
+ *kf_foot_r = &pose->keyframes[localplayer.id_ik_foot_r-1],
+ *kf_knee_l = &pose->keyframes[localplayer.id_ik_knee_l-1],
+ *kf_knee_r = &pose->keyframes[localplayer.id_ik_knee_r-1],
+ *kf_hip = &pose->keyframes[localplayer.id_hip-1],
+ *kf_wheels[] = { &pose->keyframes[localplayer.id_wheel_r-1],
+ &pose->keyframes[localplayer.id_wheel_l-1] };
mdl_keyframe grind_pose[32];
float add_grab_mod = 1.0f - animator->fly;
/* additive effects */
- u32 apply_to[] = { av->id_hip,
- av->id_ik_hand_l,
- av->id_ik_hand_r,
- av->id_ik_elbow_l,
- av->id_ik_elbow_r };
+ u32 apply_to[] = { localplayer.id_hip,
+ localplayer.id_ik_hand_l,
+ localplayer.id_ik_hand_r,
+ localplayer.id_ik_elbow_l,
+ localplayer.id_ik_elbow_r };
float apply_rates[] = { 1.0f,
0.75f,
/* angle 'correction' */
v3f origin;
- v3_add( av->sk.bones[av->id_hip].co, kf_hip->co, origin );
+ v3_add( sk->bones[localplayer.id_hip].co, kf_hip->co, origin );
for( int i=0; i<vg_list_size(apply_to); i ++ ){
mdl_keyframe *kf = &pose->keyframes[apply_to[i]-1];
- keyframe_rotate_around( kf, origin, av->sk.bones[apply_to[i]].co,
+ keyframe_rotate_around( kf, origin, sk->bones[apply_to[i]].co,
animator->qfixuptotal );
}
q_normalize( kf_wheels[i]->q );
}
-#if 0
{
mdl_keyframe
- *kf_head = &pose->keyframes[av->id_head-1],
- *kf_elbow_l = &pose->keyframes[av->id_ik_elbow_l-1],
- *kf_elbow_r = &pose->keyframes[av->id_ik_elbow_r-1],
- *kf_hand_l = &pose->keyframes[av->id_ik_hand_l-1],
- *kf_hand_r = &pose->keyframes[av->id_ik_hand_r-1];
+ *kf_head = &pose->keyframes[localplayer.id_head-1],
+ *kf_elbow_l = &pose->keyframes[localplayer.id_ik_elbow_l-1],
+ *kf_elbow_r = &pose->keyframes[localplayer.id_ik_elbow_r-1],
+ *kf_hand_l = &pose->keyframes[localplayer.id_ik_hand_l-1],
+ *kf_hand_r = &pose->keyframes[localplayer.id_ik_hand_r-1];
float warble = perlin1d( vg.time, 2.0f, 2, 300 );
warble *= vg_maxf(animator->grind, fabsf(animator->weight)) * 0.3f;
v3f origin = {0.0f,0.2f,0.0f};
keyframe_rotate_around( kf_hand_l, origin,
- av->sk.bones[av->id_ik_hand_l].co, qrot );
+ sk->bones[localplayer.id_ik_hand_l].co, qrot );
keyframe_rotate_around( kf_hand_r, origin,
- av->sk.bones[av->id_ik_hand_r].co, qrot );
+ sk->bones[localplayer.id_ik_hand_r].co, qrot );
keyframe_rotate_around( kf_hip, origin,
- av->sk.bones[av->id_hip].co, qrot );
+ sk->bones[localplayer.id_hip].co, qrot );
keyframe_rotate_around( kf_elbow_r, origin,
- av->sk.bones[av->id_ik_elbow_r].co, qrot );
+ sk->bones[localplayer.id_ik_elbow_r].co, qrot );
keyframe_rotate_around( kf_elbow_l, origin,
- av->sk.bones[av->id_ik_elbow_l].co, qrot );
+ sk->bones[localplayer.id_ik_elbow_l].co, qrot );
q_inv( qrot, qrot );
q_mul( qrot, kf_head->q, kf_head->q );
q_normalize( kf_head->q );
}
-#endif
}
static void player__skate_post_animate(void){
- struct player_avatar *av = localplayer.playeravatar;
struct player_skate_state *state = &player_skate.state;
-
localplayer.cam_velocity_influence = 1.0f;
v3f head = { 0.0f, 1.8f, 0.0f };
- m4x3_mulv( localplayer.final_mtx[ av->id_head ],
+ m4x3_mulv( localplayer.final_mtx[ localplayer.id_head ],
head, state->head_position );
m4x3_mulv( localplayer.rb.to_local,
state->head_position, state->head_position );
w->state.outro_start_time = vg.time;
localplayer.immobile = 1;
- struct player_avatar *av = localplayer.playeravatar;
- m4x3_mulv( localplayer.final_mtx[ av->id_ik_foot_r ],
- av->sk.bones[ av->id_ik_foot_r ].co,
+ u32 foot_id = localplayer.id_ik_foot_r;
+
+ m4x3_mulv( localplayer.final_mtx[ foot_id ],
+ localplayer.skeleton.bones[ foot_id ].co,
w->state.drop_in_foot_anchor );
}
else{
}
if( w->state.outro_type ){
- struct player_avatar *av = localplayer.playeravatar;
struct skeleton_anim *anim =
player_walk_outro_anim( w->state.outro_type );
f32 outro_length = (f32)anim->length / anim->rate,
static void player__walk_pose( void *_animator, player_pose *pose ){
struct player_walk *w = &player_walk;
struct player_walk_animator *animator = _animator;
- struct skeleton *sk = &localplayer.playeravatar->sk;
- struct player_avatar *av = localplayer.playeravatar;
+ struct skeleton *sk = &localplayer.skeleton;
v3_copy( animator->root_co, pose->root_co );
v4_copy( animator->root_q, pose->root_q );
skeleton_sample_anim( sk, w->anim_sit, st*sit_norm, bpose );
v4f qy,qp;
- f32 *qh = bpose[av->id_head-1].q;
+ f32 *qh = bpose[localplayer.id_head-1].q;
q_axis_angle( qy, (v3f){0.0f,1.0f,0.0f}, animator->yaw*0.5f*st );
q_axis_angle( qp, (v3f){0.0f,0.0f,1.0f}, animator->pitch*st );
q_mul( qy, qh, qh );
q_mul( qh, qp, qh );
q_normalize( qh );
- qh = bpose[av->id_chest-1].q;
+ qh = bpose[localplayer.id_chest-1].q;
q_axis_angle( qy, (v3f){0.0f,1.0f,0.0f}, animator->yaw*0.5f*st );
q_mul( qy, qh, qh );
q_normalize( qh );
v3f anchored_pos;
m4x3_mulv( inverse, animator->foot_anchor, anchored_pos );
- v3_lerp( pose->keyframes[ av->id_ik_foot_r-1 ].co, anchored_pos,
+ v3_lerp( pose->keyframes[ localplayer.id_ik_foot_r-1 ].co,
+ anchored_pos,
1.0f-animator->commit_t,
- pose->keyframes[ av->id_ik_foot_r-1 ].co );
+ pose->keyframes[ localplayer.id_ik_foot_r-1 ].co );
}
}
else
* Camera
*/
struct player_walk *w = &player_walk;
- struct player_avatar *av = localplayer.playeravatar;
if( w->state.outro_type ){
struct skeleton_anim *anim = player_walk_outro_anim(w->state.outro_type);
static void player__walk_bind(void){
struct player_walk *w = &player_walk;
- struct player_avatar *av = localplayer.playeravatar;
- struct skeleton *sk = &av->sk;
+ struct skeleton *sk = &localplayer.skeleton;
w->anim_idle = skeleton_get_anim( sk, "idle_cycle+y" );
w->anim_walk = skeleton_get_anim( sk, "walk+y" );
#include "player_remote.c"
#include "vg/vg_audio_dsp.h"
-static struct player_avatar localplayer_avatar;
static int k_tools_mode = 0;
int main( int argc, char *argv[] ){
}
static void vg_preload(void){
- //skaterift_read_savedata();
-
vg_info(" Copyright . . . -----, ,----- ,---. .---. \n" );
vg_info(" 2021-2023 |\\ /| | / | | | | /| \n" );
vg_info(" | \\ / | +-- / +----- +---' | / | \n" );
vg_info(" ' ' '--' [] '----- '----- ' ' '---' "
"SOFTWARE\n" );
+ vg_loader_step( remote_players_init, NULL );
+
if( k_tools_mode )
return;
steam_init();
vg_loader_step( NULL, steam_end );
- vg_loader_step( remote_players_init, NULL );
vg_loader_step( network_init, network_end );
}
skaterift.replay.size = bytes;
replay_clear( &skaterift.replay );
- player_avatar_load( &localplayer_avatar, "models/ch_none.mdl" );
- player__use_avatar( &localplayer_avatar );
-
- /* FIXME FIXME FIXME FIXME FIXME */
- u32 mtx_size = sizeof(m4x3f)*localplayer_avatar.sk.bone_count;
- localplayer.final_mtx = vg_linear_alloc( vg_mem.rtmemory, mtx_size );
- netplayers.final_mtx = vg_linear_alloc( vg_mem.rtmemory,
- mtx_size*NETWORK_MAX_PLAYERS );
+ player_load_animation_reference( "models/ch_none.mdl" );
player_model_load( &localplayer.fallback_model, "models/ch_none.mdl" );
player__bind();
workshop_form_gui();
render_view_framebuffer_ui();
remote_player_network_imgui( vg.pv );
- remote_players_imgui();
+
+
+ remote_players_imgui_world( world_current_instance(), vg.pv, INFINITY );
+ if( skaterift.activity == k_skaterift_respawning ){
+ remote_players_imgui_lobby();
+ }
}
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
- struct skeleton *sk = &localplayer.playeravatar->sk;
+ struct skeleton *sk = &localplayer.skeleton;
player_pose res;
res.type = k_player_pose_type_ik;
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff