X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_remote.c;h=43c56079cd436123f39f638e8f4706aa7e6581f4;hb=HEAD;hp=d9ee7b8243a8f95e190add9c2075dc802ec160d9;hpb=46f4e9ee87dc67402166e4c6b05efbe922cd7574;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/player_remote.c b/player_remote.c index d9ee7b8..43c5607 100644 --- a/player_remote.c +++ b/player_remote.c @@ -1,31 +1,108 @@ #include "player_remote.h" +#include "skeleton.h" +#include "player_render.h" +#include "player_api.h" +#include "network_common.h" +#include "addon.h" +#include "font.h" +#include "gui.h" +#include "ent_miniworld.h" +#include "ent_region.h" +#include "shaders/model_entity.h" +#include "vg/vg_steam_friends.h" -static void player_remote_unwatch( struct network_player *player ){ +struct global_netplayers netplayers; + +static i32 k_show_own_name = 0; + +static void player_remote_clear( struct network_player *player ) +{ addon_cache_unwatch( k_addon_type_player, player->playermodel_view_slot ); addon_cache_unwatch( k_addon_type_board, player->board_view_slot ); -} -static void player_remote_clear( struct network_player *player ){ - player_remote_unwatch( player ); memset( player, 0, sizeof(*player) ); strcpy( player->username, "unknown" ); player->subsystem = k_player_subsystem_invalid; } -static void player_remote_packet( SteamNetworkingMessage_t *msg ){ +/* + * re-attatches addon_reg pointers on the remote client if we have the same + * world loaded. + */ +static void relink_remote_player_worlds( u32 client_id ){ + struct network_player *player = &netplayers.list[client_id]; + + addon_alias q[2]; + addon_uid_to_alias( player->items[k_netmsg_playeritem_world0], &q[0] ); + addon_uid_to_alias( player->items[k_netmsg_playeritem_world1], &q[1] ); + + /* + * currently in 10.23, the hub world will always be the same. + * this might but probably wont change in the future + */ + for( u32 i=0; iworld_match[i] = 0; + + if( reg ){ + if( addon_alias_eq( &q[i], &world_static.instance_addons[i]->alias ) ) + player->world_match[i] = 1; + } + } +} + +/* + * re-attatches addon_reg pointers on the remote client if we have the mod + * installed locally. + * + * Run if local worlds change + */ +void relink_all_remote_player_worlds(void) +{ + for( u32 i=0; iactive ) + relink_remote_player_worlds(i); + } +} + +void player_remote_update_friendflags( struct network_player *remote ) +{ + ISteamFriends *hSteamFriends = SteamAPI_SteamFriends(); + remote->isfriend = SteamAPI_ISteamFriends_HasFriend( hSteamFriends, + remote->steamid, k_EFriendFlagImmediate ); + remote->isblocked = SteamAPI_ISteamFriends_HasFriend( hSteamFriends, + remote->steamid, k_EFriendFlagBlocked ); +} + +void player_remote_rx_200_300( SteamNetworkingMessage_t *msg ) +{ netmsg_blank *tmp = msg->m_pData; if( tmp->inetmsg_id == k_inetmsg_playerjoin ){ netmsg_playerjoin *playerjoin = msg->m_pData; + if( !packet_minsize( msg, sizeof(*playerjoin) )) return; if( playerjoin->index < vg_list_size(netplayers.list) ){ struct network_player *player = &netplayers.list[ playerjoin->index ]; player_remote_clear( player ); player->active = 1; + player->steamid = playerjoin->steamid; + player_remote_update_friendflags( player ); /* TODO: interpret the uids */ player->board_view_slot = 0; player->playermodel_view_slot = 0; + + struct interp_buffer *buf = &netplayers.interp_data[playerjoin->index]; + buf->t = -99999999.9; + for( u32 i=0; iframes); i ++ ){ + buf->frames[i].active = 0; + } + + vg_info( "#%u joined friend: %d, blocked: %d\n", + playerjoin->index, player->isfriend, player->isblocked ); } else { vg_error( "inetmsg_playerjoin: player index out of range\n" ); @@ -33,32 +110,356 @@ static void player_remote_packet( SteamNetworkingMessage_t *msg ){ } else if( tmp->inetmsg_id == k_inetmsg_playerleave ){ netmsg_playerleave *playerleave = msg->m_pData; + if( !packet_minsize( msg, sizeof(*playerleave) )) return; if( playerleave->index < vg_list_size(netplayers.list) ){ struct network_player *player = &netplayers.list[ playerleave->index ]; - player_remote_unwatch( player ); + player_remote_clear( player ); player->active = 0; + vg_info( "player leave (%d)\n", playerleave->index ); + } + else { + vg_error( "inetmsg_playerleave: player index out of range\n" ); + } + } + else if( tmp->inetmsg_id == k_inetmsg_playerusername ){ + netmsg_playerusername *update = msg->m_pData; + if( !packet_minsize( msg, sizeof(*update) )) return; + + if( update->index < vg_list_size(netplayers.list) ){ + struct network_player *player = &netplayers.list[ update->index ]; + + network_msgstring( update->name, msg->m_cbSize, sizeof(*update), + player->username, sizeof(player->username) ); + + vg_info( "#%u changed username to: %s\n", + update->index, player->username ); } else { vg_error( "inetmsg_playerleave: player index out of range\n" ); } } + else if( tmp->inetmsg_id == k_inetmsg_playerframe ){ + u32 datasize = msg->m_cbSize - sizeof(netmsg_playerframe); + + if( datasize > sizeof(union interp_animdata) ){ + vg_error( "Player frame data exceeds animdata size\n" ); + return; + } + + netmsg_playerframe *frame = msg->m_pData; + + if( frame->client >= vg_list_size(netplayers.list) ){ + vg_error( "inetmsg_playerframe: player index out of range\n" ); + return; + } + + if( frame->subsystem >= k_player_subsystem_max ){ + vg_error( "inetmsg_playerframe: subsystem out of range\n" ); + return; + } + + struct interp_buffer *ib = &netplayers.interp_data[ frame->client ]; + struct interp_frame *dest = NULL; + + f64 min_time = INFINITY; + for( u32 i=0; iframes); i++ ){ + struct interp_frame *ifr = &ib->frames[i]; + + if( !ifr->active ){ + dest = ifr; + break; + } + + if( ifr->timestamp < min_time ){ + min_time = ifr->timestamp; + dest = ifr; + } + } + + dest->active = 1; + dest->subsystem = frame->subsystem; + dest->flags = frame->flags; + + bitpack_ctx ctx = { + .mode = k_bitpack_decompress, + .buffer = frame->animdata, + .buffer_len = datasize, + .bytes = 0, + }; + + /* animation + * -------------------------------------------------------------*/ + + dest->timestamp = frame->timestamp; + dest->boundary_hash = frame->boundary_hash; + + struct network_player *player = &netplayers.list[ frame->client ]; + struct player_subsystem_interface *sys = + player_subsystems[ frame->subsystem ]; + + memset( &dest->data, 0, sys->animator_size ); + if( sys->network_animator_exchange ) + sys->network_animator_exchange( &ctx, &dest->data ); + else + bitpack_bytes( &ctx, sys->animator_size, sys->animator_data ); + + /* sfx + * -------------------------------------------------------------*/ + + for( u32 i=0; isound_effects; i ++ ){ + struct net_sfx sfx; + net_sfx_exchange( &ctx, &sfx ); + + f64 t = (frame->timestamp - NETWORK_FRAMERATE) + + (sfx.subframe*NETWORK_FRAMERATE); + + f32 remaining = t - ib->t; + + if( remaining <= 0.0f ) + net_sfx_play( &sfx ); + else{ + struct net_sfx *dst = NULL; + + for( u32 j=0; jsystem == k_player_subsystem_invalid ){ + dst = sj; + break; + } + + if( sj->priority < sfx.priority ) + dst = sj; + } + + *dst = sfx; + dst->subframe = remaining; + } + } + + /* glider + * -------------------------------------------------------------*/ + + memset( &dest->data_glider, 0, sizeof(struct remote_glider_animator) ); + if( dest->flags & (NETMSG_PLAYERFRAME_HAVE_GLIDER| + NETMSG_PLAYERFRAME_GLIDER_ORPHAN) ){ + player_glide_remote_animator_exchange( &ctx, &dest->data_glider ); + } + + player->subsystem = frame->subsystem; + player->down_bytes += msg->m_cbSize; + } + else if( tmp->inetmsg_id == k_inetmsg_playeritem ){ + netmsg_playeritem *item = msg->m_pData; + if( !packet_minsize( msg, sizeof(*item)+1 )) return; + + if( item->client >= vg_list_size(netplayers.list) ){ + vg_error( "inetmsg_playerframe: player index out of range\n" ); + return; + } + + if( item->type_index >= k_netmsg_playeritem_max ){ + vg_warn( "Client #%d invalid equip type %u\n", + (i32)item->client, (u32)item->type_index ); + return; + } + + vg_info( "Client #%d equiped: [%s] %s\n", + item->client, + (const char *[]){[k_netmsg_playeritem_board]="board", + [k_netmsg_playeritem_player]="player", + [k_netmsg_playeritem_world0]="world0", + [k_netmsg_playeritem_world1]="world1" + }[item->type_index], item->uid ); + + struct network_player *player = &netplayers.list[ item->client ]; + char *uid = player->items[ item->type_index ]; + + network_msgstring( item->uid, msg->m_cbSize, sizeof(*item), + uid, ADDON_UID_MAX ); + + if( item->type_index == k_netmsg_playeritem_board ){ + addon_cache_unwatch( k_addon_type_board, player->board_view_slot ); + player->board_view_slot = + addon_cache_create_viewer_from_uid( k_addon_type_board, uid ); + } + else if( item->type_index == k_netmsg_playeritem_player ){ + addon_cache_unwatch( k_addon_type_player, + player->playermodel_view_slot ); + player->playermodel_view_slot = + addon_cache_create_viewer_from_uid( k_addon_type_player, uid ); + } + else if( (item->type_index == k_netmsg_playeritem_world0) || + (item->type_index == k_netmsg_playeritem_world1) ){ + relink_remote_player_worlds( item->client ); + } + } + else if( tmp->inetmsg_id == k_inetmsg_chat ){ + netmsg_chat *chat = msg->m_pData; + + struct network_player *player = &netplayers.list[ chat->client ]; + network_msgstring( chat->msg, msg->m_cbSize, sizeof(netmsg_chat), + player->chat, NETWORK_MAX_CHAT ); + player->chat_time = vg.time_real; + vg_info( "[%d]: %s\n", chat->client, player->chat ); + } + else if( tmp->inetmsg_id == k_inetmsg_region ){ + netmsg_region *region = msg->m_pData; + struct network_player *player = &netplayers.list[ region->client ]; + + u32 l = network_msgstring( + region->loc, msg->m_cbSize, sizeof(netmsg_region), + player->region, NETWORK_REGION_MAX ); + player->region_flags = region->flags; + + if( l ) + player->region_flags |= k_ent_region_flag_hasname; + + player->effect_data.spark.colour = region_spark_colour(region->flags); + } } -static void remote_player_network_imgui(void){ +/* + * Write localplayer pose to network + */ +void remote_player_send_playerframe(void) +{ + u8 sysid = localplayer.subsystem; + if( sysid >= k_player_subsystem_max ) return; + + struct player_subsystem_interface *sys = player_subsystems[sysid]; + + if( sys->animator_size ){ + u32 max_buf_size = sys->animator_size + sizeof(localplayer.sfx_buffer), + base_size = sizeof(struct netmsg_playerframe), + max_packet = base_size + max_buf_size; + + netmsg_playerframe *frame = alloca( max_packet ); + frame->inetmsg_id = k_inetmsg_playerframe; + frame->client = 0xff; + frame->subsystem = localplayer.subsystem; + frame->flags = world_static.active_instance; + + bitpack_ctx ctx = { + .mode = k_bitpack_compress, + .buffer = frame->animdata, + .buffer_len = max_buf_size, + .bytes = 0 + }; + + /* animation + * -----------------------------------------------*/ + + frame->timestamp = vg.time_real; + frame->boundary_hash = localplayer.boundary_hash; + if( sys->network_animator_exchange ) + sys->network_animator_exchange( &ctx, sys->animator_data ); + else + bitpack_bytes( &ctx, sys->animator_size, sys->animator_data ); + + /* sfx + * ---------------------------------------------*/ + + frame->sound_effects = localplayer.sfx_buffer_count; + for( u32 i=0; iflags |= NETMSG_PLAYERFRAME_HAVE_GLIDER; + } + + if( localplayer.glider_orphan ) + frame->flags |= NETMSG_PLAYERFRAME_GLIDER_ORPHAN; + + if( frame->flags & (NETMSG_PLAYERFRAME_HAVE_GLIDER| + NETMSG_PLAYERFRAME_GLIDER_ORPHAN) ){ + player_glide_remote_animator_exchange( &ctx, + &player_glide.remote_animator ); + } + + /* ------- */ + + u32 wire_size = base_size + ctx.bytes; + netplayers.up_bytes += wire_size; + + SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( + hSteamNetworkingSockets, network_client.remote, + frame, wire_size, + k_nSteamNetworkingSend_Unreliable, NULL ); + } +} + +/* + * Updates network traffic stats + */ +void remote_player_debug_update(void) +{ + if( (vg.time_real - netplayers.last_data_measurement) > 1.0 ){ + netplayers.last_data_measurement = vg.time_real; + u32 total_down = 0; + + for( u32 i=0; iactive ){ + total_down += player->down_bytes; + player->down_kbs = ((f32)player->down_bytes)/1024.0f; + player->down_bytes = 0; + } + } + + netplayers.down_kbs = ((f32)total_down)/1024.0f; + netplayers.up_kbs = ((f32)netplayers.up_bytes)/1024.0f; + netplayers.up_bytes = 0; + } +} + +/* + * Debugging information + */ +void remote_player_network_imgui( m4x4f pv ) +{ + if( network_client.user_intent == k_server_intent_online ){ + if( !(steam_ready && + (network_client.state == k_ESteamNetworkingConnectionState_Connected))) + { + char buf[128]; + vg_str str; + vg_strnull( &str, buf, sizeof(buf) ); + u32 fg = 0; + network_status_string( &str, &fg ); + ui_text( (ui_rect){ vg.window_x - 200, 0, 200, 48 }, buf, 1, + k_ui_align_middle_center, fg ); + } + } + if( !network_client.network_info ) return; ui_rect panel = { (vg.window_x / 2) - 200, 0, 400, 600 }; ui_fill( panel, (ui_colour(k_ui_bg)&0x00ffffff)|0x50000000 ); + ui_font_face( &vgf_default_title ); + ui_info( panel, "Network" ); + ui_font_face( &vgf_default_large ); + ui_info( panel, "Status" ); + ui_font_face( &vgf_default_small ); + char buf[512]; const char *netstatus = "PROGRAMMING ERROR"; struct { enum ESteamNetworkingConnectionState state; const char *str; } states[] = { { k_ESteamNetworkingConnectionState_None, "None" }, - { k_ESteamNetworkingConnectionState_Connecting, "Connecting" }, + { k_ESteamNetworkingConnectionState_Connecting, + (const char *[]){"Connecting -", + "Connecting /", + "Connecting |", + "Connecting \\", + }[(u32)(vg.time_real/0.25) & 0x3 ] }, { k_ESteamNetworkingConnectionState_FindingRoute, "Finding Route" }, { k_ESteamNetworkingConnectionState_Connected, "Connected" }, { k_ESteamNetworkingConnectionState_ClosedByPeer, "Closed by peer" }, @@ -78,17 +479,656 @@ static void remote_player_network_imgui(void){ ui_info( panel, buf ); ui_info( panel, "---------------------" ); - for( u32 i=0; iactive ){ + const char *sysname = "invalid"; + + if( player->subsystem < k_player_subsystem_max ){ + sysname = player_subsystems[ player->subsystem ]->name; + } + snprintf( buf, 512, "#%u: %s [%s] D%.1fkbs", + i, player->username, sysname, player->down_kbs ); + ui_info( panel, buf ); + } + } + } + else { + ui_info( panel, "offline" ); + } +} + +static void remote_player_effect( struct network_player *player, + player_pose *final_pose ){ + /* effects */ +} + +/* + * write the remote players final_mtx + */ +static void pose_remote_player( u32 index, + struct interp_frame *f0, + struct interp_frame *f1 ){ + + struct network_player *player = &netplayers.list[ index ]; + + struct interp_buffer *buf = &netplayers.interp_data[ 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], + *sys1 = NULL; + + struct player_board *board = + addon_cache_item_if_loaded( k_addon_type_board, player->board_view_slot ); + + player_pose pose0, pose1, posed; + sys0->pose( &f0->data, &pose0 ); + + u8 instance_id = 0; + + f32 t = 0.0f; + + if( f1 ){ + t = (buf->t - f0->timestamp) / (f1->timestamp - f0->timestamp); + t = vg_clampf( t, 0.0f, 1.0f ); + + sys1 = player_subsystems[f1->subsystem]; + sys1->pose( &f1->data, &pose1 ); + + u16 bounds = f0->boundary_hash^f1->boundary_hash; + + if( bounds & NETMSG_BOUNDARY_BIT ) + t = 1.0f; + + if( bounds & NETMSG_GATE_BOUNDARY_BIT ){ + /* TODO: Extra work retransforming the root_co, instance_id.. etc */ + t = 1.0f; + } + + instance_id = f1->flags & NETMSG_PLAYERFRAME_INSTANCE_ID; + lerp_player_pose( &pose0, &pose1, t, &posed ); + effect_blink_apply( &player->effect_data.blink, &posed, vg.time_delta ); + + apply_full_skeleton_pose( sk, &posed, final_mtx ); + + if( t < 0.5f ){ + if( sys0->effects ) + sys0->effects( &f0->data, final_mtx, board, &player->effect_data ); + } + else{ + if( sys1->effects ) + sys1->effects( &f1->data, final_mtx, board, &player->effect_data ); + } + + memcpy( board_pose, &posed.board, sizeof(*board_pose) ); + } + else { + instance_id = f0->flags & NETMSG_PLAYERFRAME_INSTANCE_ID; + effect_blink_apply( &player->effect_data.blink, &pose0, vg.time_delta ); + apply_full_skeleton_pose( sk, &pose0, final_mtx ); + if( sys0->effects ) + sys0->effects( &f0->data, final_mtx, board, &player->effect_data ); + memcpy( board_pose, &pose0.board, sizeof(*board_pose) ); + } + + if( f0->flags & (NETMSG_PLAYERFRAME_HAVE_GLIDER| + NETMSG_PLAYERFRAME_GLIDER_ORPHAN) ){ + player->render_glider = 1; + + v3f co; + v4f q; + f32 s; + + if( f1 ){ + v3_lerp( f0->data_glider.root_co, f1->data_glider.root_co, t, co ); + q_nlerp( f0->data_glider.root_q, f1->data_glider.root_q, t, q ); + s = vg_lerpf( f0->data_glider.s, f1->data_glider.s, t ); + } + else { + v3_copy( f0->data_glider.root_co, co ); + v4_copy( f0->data_glider.root_q, q ); + s = f0->data_glider.s; + } + + v3f *mtx = netplayers.glider_mtx[ index ]; + q_m3x3( q, mtx ); + m3x3_scalef( mtx, s ); + v3_copy( co, mtx[3] ); + } + else + player->render_glider = 0; + + if( player->world_match[ instance_id ] ) + player->active_world = &world_static.instances[ instance_id ]; +} + +/* + * animate remote player and store in final_mtx + */ +void animate_remote_player( u32 index ) +{ + /* + * Trys to keep the cursor inside the buffer + */ + f64 min_time = -999999999.9, + max_time = 999999999.9, + abs_max_time = -999999999.9; + + struct interp_frame *minframe = NULL, + *maxframe = NULL, + *abs_max_frame = NULL; + + struct interp_buffer *buf = &netplayers.interp_data[index]; + for( u32 i=0; iframes); i ++ ){ + struct interp_frame *ifr = &buf->frames[i]; + + if( ifr->active ){ + if( (ifr->timestamp > min_time) && (ifr->timestamp < buf->t) ){ + min_time = ifr->timestamp; + minframe = ifr; + } + + if( (ifr->timestamp < max_time) && (ifr->timestamp > buf->t) ){ + max_time = ifr->timestamp; + maxframe = ifr; + } + + if( ifr->timestamp > abs_max_time ){ + abs_max_time = ifr->timestamp; + abs_max_frame = ifr; + } + } + } + + struct network_player *player = &netplayers.list[ index ]; + if( player->active != 2 ) + player->active_world = NULL; + + if( minframe && maxframe ){ + pose_remote_player( index, minframe, maxframe ); + buf->t += vg.time_frame_delta; + } + else { + buf->t = abs_max_time - 0.25; + + if( abs_max_frame ) + pose_remote_player( index, abs_max_frame, NULL ); + else + return; + } +} + +/* + * Update full final_mtx for all remote players + */ +void animate_remote_players(void) +{ + for( u32 i=0; iactive ) continue; + + animate_remote_player( i ); + } +} + +/* + * Draw remote players + */ +void render_remote_players( world_instance *world, vg_camera *cam ) +{ + u32 draw_list[ NETWORK_MAX_PLAYERS ], + draw_list_count = 0, + gliders = 0; + + for( u32 i=0; iactive || player->isblocked ) continue; + if( player->active_world != world ) continue; + +#if 0 + if( !player->isfriend && + (world-world_static.instances == k_world_purpose_hub)) continue; +#endif + + draw_list[draw_list_count ++] = i; + + if( player->render_glider ) + gliders ++; + } + + struct skeleton *sk = &localplayer.skeleton; + + SDL_AtomicLock( &addon_system.sl_cache_using_resources ); + + for( u32 j=0; jbone_count*index ]; + + 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, 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.id_board], + &netplayers.board_poses[ index ], k_board_shader_player ); + } + + SDL_AtomicUnlock( &addon_system.sl_cache_using_resources ); + + if( !gliders ) + return; + + /* TODO: we really, really only need to do all this once. at some point + * PLEASE figure out a good place to do this once per frame! + */ + + shader_model_entity_use(); + shader_model_entity_uTexMain( 0 ); + shader_model_entity_uCamera( cam->transform[3] ); + shader_model_entity_uPv( cam->mtx.pv ); + + WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( world, model_entity ); + + for( u32 j=0; jrender_glider ) continue; + + if( player->render_glider ){ + v3f *glider_mtx = netplayers.glider_mtx[ index ]; + render_glider_model( cam, world, glider_mtx, k_board_shader_entity ); + } + } +} + +static int remote_players_randomize( int argc, const char *argv[] ){ + for( int i=0; iactive = (vg_randu32(&vg.rand) & 0x1)? 2: 0; + player->isfriend = vg_randu32(&vg.rand) & vg_randu32(&vg.rand) & 0x1; + player->isblocked = vg_randu32(&vg.rand) & + vg_randu32(&vg.rand) & + vg_randu32(&vg.rand) & 0x1; + player->world_match[ 0 ] = vg_randu32(&vg.rand) & 0x1; + player->world_match[ 1 ] = 0; + + if( player->world_match[0] ) + player->active_world = &world_static.instances[0]; + else + player->active_world = NULL; + + for( int i=0; iusername)-1; i ++ ){ + player->username[i] = 'a' + (vg_randu32(&vg.rand) % 30); + player->username[i+1] = '\0'; + + if( (vg_randu32(&vg.rand) % 8) == 3 ) + break; + } + + for( int i=0; i<3; i ++ ){ + player->medals[i] = vg_randu32(&vg.rand) % 3; + } + + v3f pos; + + vg_rand_sphere( &vg.rand, pos ); + v3_muladds( localplayer.rb.co, pos, 100.0f, + netplayers.final_mtx[ i*localplayer.skeleton.bone_count][3] ); + } + + return 0; +} + +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; isystem != k_player_subsystem_invalid ){ + si->subframe -= vg.time_frame_delta; + if( si->subframe <= 0.0f ){ + net_sfx_play( si ); + si->system = k_player_subsystem_invalid; + } + } + } +} + +/* + * animator->root_co of remote player + */ +static void remote_player_position( int id, v3f out_co ){ + struct skeleton *sk = &localplayer.skeleton; + m4x3f *final_mtx = &netplayers.final_mtx[ sk->bone_count*id ]; + v3_copy( final_mtx[0][3], out_co ); +} + +enum remote_player_gui_type { + k_remote_player_gui_type_stranger, + k_remote_player_gui_type_friend, + k_remote_player_gui_type_you, +}; + +/* + * Given players' root_co, get the screen point where we should draw tag info. + */ +static int player_tag_position( m4x4f pv, v3f root_co, ui_point out_point ){ + v4f wpos; + v3_copy( root_co, wpos ); + wpos[1] += 2.0f; + wpos[3] = 1.0f; + + m4x4_mulv( pv, wpos, wpos ); + + if( wpos[3] > 0.0f ){ + v2_muls( wpos, (1.0f/wpos[3]) * 0.5f, wpos ); + v2_add( wpos, (v2f){ 0.5f, 0.5f }, wpos ); + + float k_max = 32000.0f; + + out_point[0] = vg_clampf(wpos[0] * vg.window_x, -k_max, k_max ); + out_point[1] = vg_clampf((1.0f-wpos[1]) * vg.window_y, -k_max, k_max ); + return 1; + } + else + return 0; +} + +/* + * Draw chat box relative to the root tag position on the screen + */ +static void chat_box( ui_point tag_root, f64 time, const char *message ) +{ + if( (vg.time_real - time) > 15.0 ) + return; + + ui_rect wr; + wr[2] = ui_text_line_width( message ) + 8; + wr[3] = vg_ui.font->ch + 2; + wr[0] = tag_root[0]-(wr[2]/2); + wr[1] = tag_root[1] - wr[3] - 8; + + ui_fill( wr, ui_opacity( ui_colour(k_ui_bg), 0.23f ) ); + ui_text( wr, message, 1, k_ui_align_middle_center, 0 ); +} + +/* + * Draw full imgui for remote player + */ +static void remote_player_nametag( ui_point tag_root, + struct network_player *player ) +{ + ui_font_face( &vgf_default_large ); + + ui_rect wr; + wr[2] = VG_MAX( ui_text_line_width( player->username ), 140 ) + 8; + wr[3] = 32; + wr[0] = tag_root[0]-(wr[2]/2); + wr[1] = tag_root[1]-(wr[3]/2); + + ui_fill( wr, ui_opacity( ui_colour(k_ui_bg), 0.23f ) ); + ui_text( wr, player->username, 1, k_ui_align_middle_center, 0 ); + + ui_font_face( &vgf_default_small ); + + /* medals */ + int cols = 0; + for( int i=0; i<3; i ++ ) + if( player->medals[i] ) + cols ++; + + char buf[32]; + vg_str str; + + if( cols ){ + f32 w = (f32)wr[2] / (f32)cols; + cols = 0; + + for( int i=0; i<3; i ++ ){ + if( player->medals[i] ){ + ui_rect col = { wr[0] + (f32)cols*w, wr[1] + wr[3], w, + vg_ui.font->ch }; + + vg_strnull( &str, buf, 32 ); +#if 0 + vg_strcatch( &str, (char)k_SRglyph_vg_circle ); +#endif + vg_strcati32( &str, player->medals[i] ); + + ui_text( col, buf, 1, k_ui_align_middle_center, + ui_colour( (enum ui_scheme_colour[]){ + k_ui_yellow, k_ui_gray, k_ui_orange }[i] ) ); + + cols ++; + } + } + } +} + +static void remote_player_world_gui( m4x4f pv, v3f root_co, + struct network_player *player ){ + ui_point tag_root; + if( !player_tag_position( pv, root_co, tag_root ) ) + return; + + if( player ){ + remote_player_nametag( tag_root, player ); + chat_box( tag_root, player->chat_time, player->chat ); + } + else { + if( netplayers.chatting ) + chat_box( tag_root, vg.time_real, netplayers.chat_buffer ); + else + chat_box( tag_root, netplayers.chat_time, netplayers.chat_message ); + } +} + +static void remote_player_gui_info( ui_rect box, + const char *username, + const char *activity, + enum remote_player_gui_type type, + int in_world ){ + + f32 opacity = in_world? 0.6f: 0.3f; + + if( type == k_remote_player_gui_type_you ) + ui_fill( box, ui_opacity( 0xff555555, opacity ) ); + else + ui_fill( box, ui_opacity( 0xff000000, opacity ) ); + + if( type == k_remote_player_gui_type_friend ) + ui_outline( box, -1, ui_opacity( 0xff00c4f0, opacity ), 0 ); + + ui_rect top, bottom; + ui_split_ratio( box, k_ui_axis_h, 0.6666f, 1, top, bottom ); + + u32 fg; + + if( type == k_remote_player_gui_type_friend ) + fg = ui_colour( k_ui_yellow + (in_world? k_ui_brighter: 0) ); + else + fg = ui_colour( in_world? k_ui_fg: k_ui_fg+4 ); + + ui_font_face( &vgf_default_large ); + ui_text( top, username, 1, k_ui_align_middle_center, fg ); + ui_font_face( &vgf_default_small ); + + ui_text( bottom, activity, 1, k_ui_align_middle_center, fg ); +} + +void remote_players_imgui_lobby(void) +{ + if( network_client.user_intent == k_server_intent_online ){ + if( !(steam_ready && + (network_client.state == k_ESteamNetworkingConnectionState_Connected))) + { + return; + } + } + + ui_px y = 50, width = 200, height = 42, gap = 2, + x = vg.window_x - width; + + ui_font_face( &vgf_default_large ); + ui_text( (ui_rect){ x, 0, width, height }, + "In World", 1, k_ui_align_middle_center, 0 ); + ui_font_face( &vgf_default_small ); + + + ui_rect us = { x, y, width, height }; + /* 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; iactive || player->isblocked ) continue; + + int in_same_world = player->active_world == world_current_instance(); + if( !player->isfriend && !in_same_world ) + continue; + + const char *location = in_same_world? "": "another world"; + if( player->region_flags & k_ent_region_flag_hasname ){ + location = player->region; + } + + ui_rect box = { x, y, width, height }; + remote_player_gui_info( box, player->username, location, + player->isfriend, in_same_world ); + y += height + gap; + } +} + +void remote_players_imgui_world( world_instance *world, m4x4f pv, + f32 max_dist, int geo_cull ) +{ + ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y ); + + for( u32 i=0; iactive ){ - const char *sysname = "invalid"; + v3f co; + remote_player_position( i, co ); + + if( !player->active_world ) + continue; + if( !player->isfriend && + (world-world_static.instances == k_world_purpose_hub)) continue; + + /* their in our active subworld */ + if( player->active_world != world ){ + m4x3_mulv( global_miniworld.mmdl, co, co ); + co[1] -= 2.0f; /* HACK lol */ + } + + f32 d2 = v3_dist2( co, localplayer.rb.co ); + + if( d2 > (max_dist*max_dist) ) + continue; + + f32 dist = sqrtf(d2); + f32 opacity = 0.95f * sqrtf(((max_dist-dist)/max_dist)); + + if( geo_cull ){ + ray_hit hit; + hit.dist = dist; - if( (player->subsystem >= 0) && - (player->subsystem < k_player_subsystem_max) ){ - sysname = player_subsystems[ player->subsystem ]->name; + v3f dir; + v3_sub( co, skaterift.cam.pos, dir ); + v3_normalize( dir ); + + if( ray_world( world, skaterift.cam.pos, dir, &hit, + k_material_flag_ghosts ) ){ + opacity *= 0.5f; + } + } + + player->opacity = vg_lerpf( player->opacity, opacity, + vg.time_frame_delta * 2.0f ); + + remote_player_world_gui( pv, co, player ); + + vg_ui.colour[3] = player->opacity; + ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y ); + } + } + + vg_ui.colour[3] = 1.0f; + + remote_player_world_gui( pv, localplayer.rb.co, NULL ); + ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y ); +} + +static void chat_escape(void){ + netplayers.chatting = -1; +} + +static void chat_enter( char *buf, u32 len ){ + vg_strncpy( buf, netplayers.chat_message, NETWORK_MAX_CHAT, + k_strncpy_always_add_null ); + netplayers.chatting = -1; + netplayers.chat_time = vg.time_real; + chat_send_message( buf ); +} + +void remote_players_chat_imgui(void) +{ + if( netplayers.chatting == 1 ){ + ui_rect box = { 0, 0, 400, 40 }, + window = { 0, 0, vg.window_x, vg.window_y }; + ui_rect_center( window, box ); + + struct ui_textbox_callbacks callbacks = { + .enter = chat_enter, + .escape = chat_escape + }; + + ui_textbox( box, NULL, + netplayers.chat_buffer, NETWORK_MAX_CHAT, 1, + UI_TEXTBOX_AUTOFOCUS, &callbacks ); + } + else { + if( netplayers.chatting == -1 ){ + netplayers.chatting = 0; + srinput.state = k_input_state_resume; + } + else { + if( (skaterift.activity == k_skaterift_default) && + button_down( k_srbind_chat ) ){ + netplayers.chatting = 1; + netplayers.chat_buffer[0] = '\0'; + srinput.state = k_input_state_pause; } - snprintf( buf, 512, "#%u: %s [%s]", i, player->username, sysname ); - ui_info( panel, buf ); } } }