You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2660 lines
78 KiB
2660 lines
78 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//===========================================================================// |
|
#include "cbase.h" |
|
#include <crtmemdebug.h> |
|
#include "vgui_int.h" |
|
#include "clientmode.h" |
|
#include "iinput.h" |
|
#include "iviewrender.h" |
|
#include "ivieweffects.h" |
|
#include "ivmodemanager.h" |
|
#include "prediction.h" |
|
#include "clientsideeffects.h" |
|
#include "particlemgr.h" |
|
#include "steam/steam_api.h" |
|
#include "initializer.h" |
|
#include "smoke_fog_overlay.h" |
|
#include "view.h" |
|
#include "ienginevgui.h" |
|
#include "iefx.h" |
|
#include "enginesprite.h" |
|
#include "networkstringtable_clientdll.h" |
|
#include "voice_status.h" |
|
#include "filesystem.h" |
|
#include "c_te_legacytempents.h" |
|
#include "c_rope.h" |
|
#include "engine/ishadowmgr.h" |
|
#include "engine/IStaticPropMgr.h" |
|
#include "hud_basechat.h" |
|
#include "hud_crosshair.h" |
|
#include "view_shared.h" |
|
#include "env_wind_shared.h" |
|
#include "detailobjectsystem.h" |
|
#include "clienteffectprecachesystem.h" |
|
#include "soundenvelope.h" |
|
#include "c_basetempentity.h" |
|
#include "materialsystem/imaterialsystemstub.h" |
|
#include "VGuiMatSurface/IMatSystemSurface.h" |
|
#include "materialsystem/imaterialsystemhardwareconfig.h" |
|
#include "c_soundscape.h" |
|
#include "engine/ivdebugoverlay.h" |
|
#include "vguicenterprint.h" |
|
#include "iviewrender_beams.h" |
|
#include "tier0/vprof.h" |
|
#include "engine/IEngineTrace.h" |
|
#include "engine/ivmodelinfo.h" |
|
#include "physics.h" |
|
#include "usermessages.h" |
|
#include "gamestringpool.h" |
|
#include "c_user_message_register.h" |
|
#include "IGameUIFuncs.h" |
|
#include "saverestoretypes.h" |
|
#include "saverestore.h" |
|
#include "physics_saverestore.h" |
|
#include "igameevents.h" |
|
#include "datacache/idatacache.h" |
|
#include "datacache/imdlcache.h" |
|
#include "kbutton.h" |
|
#include "tier0/icommandline.h" |
|
#include "gamerules_register.h" |
|
#include "vgui_controls/AnimationController.h" |
|
#include "bitmap/tgawriter.h" |
|
#include "c_world.h" |
|
#include "perfvisualbenchmark.h" |
|
#include "SoundEmitterSystem/isoundemittersystembase.h" |
|
#include "hud_closecaption.h" |
|
#include "colorcorrectionmgr.h" |
|
#include "physpropclientside.h" |
|
#include "panelmetaclassmgr.h" |
|
#include "c_vguiscreen.h" |
|
#include "imessagechars.h" |
|
#include "game/client/IGameClientExports.h" |
|
#include "client_factorylist.h" |
|
#include "ragdoll_shared.h" |
|
#include "rendertexture.h" |
|
#include "view_scene.h" |
|
#include "iclientmode.h" |
|
#include "con_nprint.h" |
|
#include "inputsystem/iinputsystem.h" |
|
#include "appframework/IAppSystemGroup.h" |
|
#include "scenefilecache/ISceneFileCache.h" |
|
#include "tier2/tier2dm.h" |
|
#include "tier3/tier3.h" |
|
#include "ihudlcd.h" |
|
#include "toolframework_client.h" |
|
#include "hltvcamera.h" |
|
#if defined( REPLAY_ENABLED ) |
|
#include "replay/replaycamera.h" |
|
#include "replay/replay_ragdoll.h" |
|
#include "qlimits.h" |
|
#include "replay/replay.h" |
|
#include "replay/ireplaysystem.h" |
|
#include "replay/iclientreplay.h" |
|
#include "replay/ienginereplay.h" |
|
#include "replay/ireplaymanager.h" |
|
#include "replay/ireplayscreenshotmanager.h" |
|
#include "replay/iclientreplaycontext.h" |
|
#include "replay/vgui/replayconfirmquitdlg.h" |
|
#include "replay/vgui/replaybrowsermainpanel.h" |
|
#include "replay/vgui/replayinputpanel.h" |
|
#include "replay/vgui/replayperformanceeditor.h" |
|
#endif |
|
#include "vgui/ILocalize.h" |
|
#include "vgui/IVGui.h" |
|
#include "ixboxsystem.h" |
|
#include "ipresence.h" |
|
#include "engine/imatchmaking.h" |
|
#include "cdll_bounded_cvars.h" |
|
#include "matsys_controls/matsyscontrols.h" |
|
#include "gamestats.h" |
|
#include "particle_parse.h" |
|
#if defined( TF_CLIENT_DLL ) |
|
#include "rtime.h" |
|
#include "tf_hud_disconnect_prompt.h" |
|
#include "../engine/audio/public/sound.h" |
|
#include "tf_shared_content_manager.h" |
|
#endif |
|
#include "clientsteamcontext.h" |
|
#include "renamed_recvtable_compat.h" |
|
#include "mouthinfo.h" |
|
#include "sourcevr/isourcevirtualreality.h" |
|
#include "client_virtualreality.h" |
|
#include "mumble.h" |
|
|
|
// NVNT includes |
|
#include "hud_macros.h" |
|
#include "haptics/ihaptics.h" |
|
#include "haptics/haptic_utils.h" |
|
#include "haptics/haptic_msgs.h" |
|
|
|
#if defined( TF_CLIENT_DLL ) |
|
#include "abuse_report.h" |
|
#endif |
|
|
|
#ifdef USES_ECON_ITEMS |
|
#include "econ_item_system.h" |
|
#endif // USES_ECON_ITEMS |
|
|
|
#if defined( TF_CLIENT_DLL ) |
|
#include "econ/tool_items/custom_texture_cache.h" |
|
#endif |
|
|
|
#ifdef WORKSHOP_IMPORT_ENABLED |
|
#include "fbxsystem/fbxsystem.h" |
|
#endif |
|
|
|
#include "touch.h" |
|
|
|
extern vgui::IInputInternal *g_InputInternal; |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [dwenger] Necessary for stats display |
|
//============================================================================= |
|
|
|
#include "achievements_and_stats_interface.h" |
|
|
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
|
|
#ifdef PORTAL |
|
#include "PortalRender.h" |
|
#endif |
|
|
|
#ifdef SIXENSE |
|
#include "sixense/in_sixense.h" |
|
#endif |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
extern IClientMode *GetClientModeNormal(); |
|
|
|
// IF YOU ADD AN INTERFACE, EXTERN IT IN THE HEADER FILE. |
|
IVEngineClient *engine = NULL; |
|
IVModelRender *modelrender = NULL; |
|
IVEfx *effects = NULL; |
|
IVRenderView *render = NULL; |
|
IVDebugOverlay *debugoverlay = NULL; |
|
IMaterialSystemStub *materials_stub = NULL; |
|
IDataCache *datacache = NULL; |
|
IVModelInfoClient *modelinfo = NULL; |
|
IEngineVGui *enginevgui = NULL; |
|
INetworkStringTableContainer *networkstringtable = NULL; |
|
ISpatialPartition* partition = NULL; |
|
IFileSystem *filesystem = NULL; |
|
IShadowMgr *shadowmgr = NULL; |
|
IStaticPropMgrClient *staticpropmgr = NULL; |
|
IEngineSound *enginesound = NULL; |
|
IUniformRandomStream *random = NULL; |
|
static CGaussianRandomStream s_GaussianRandomStream; |
|
CGaussianRandomStream *randomgaussian = &s_GaussianRandomStream; |
|
ISharedGameRules *sharedgamerules = NULL; |
|
IEngineTrace *enginetrace = NULL; |
|
IGameUIFuncs *gameuifuncs = NULL; |
|
IGameEventManager2 *gameeventmanager = NULL; |
|
ISoundEmitterSystemBase *soundemitterbase = NULL; |
|
IInputSystem *inputsystem = NULL; |
|
ISceneFileCache *scenefilecache = NULL; |
|
IXboxSystem *xboxsystem = NULL; // Xbox 360 only |
|
IMatchmaking *matchmaking = NULL; |
|
IUploadGameStats *gamestatsuploader = NULL; |
|
IClientReplayContext *g_pClientReplayContext = NULL; |
|
#if defined( REPLAY_ENABLED ) |
|
IReplayManager *g_pReplayManager = NULL; |
|
IReplayMovieManager *g_pReplayMovieManager = NULL; |
|
IReplayScreenshotManager *g_pReplayScreenshotManager = NULL; |
|
IReplayPerformanceManager *g_pReplayPerformanceManager = NULL; |
|
IReplayPerformanceController *g_pReplayPerformanceController = NULL; |
|
IEngineReplay *g_pEngineReplay = NULL; |
|
IEngineClientReplay *g_pEngineClientReplay = NULL; |
|
IReplaySystem *g_pReplay = NULL; |
|
#endif |
|
|
|
IHaptics* haptics = NULL;// NVNT haptics system interface singleton |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [dwenger] Necessary for stats display |
|
//============================================================================= |
|
|
|
AchievementsAndStatsInterface* g_pAchievementsAndStatsInterface = NULL; |
|
|
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
IGameSystem *SoundEmitterSystem(); |
|
IGameSystem *ToolFrameworkClientSystem(); |
|
|
|
// Engine player info, no game related infos here |
|
BEGIN_BYTESWAP_DATADESC( player_info_s ) |
|
DEFINE_ARRAY( name, FIELD_CHARACTER, MAX_PLAYER_NAME_LENGTH ), |
|
DEFINE_FIELD( userID, FIELD_INTEGER ), |
|
DEFINE_ARRAY( guid, FIELD_CHARACTER, SIGNED_GUID_LEN + 1 ), |
|
DEFINE_FIELD( friendsID, FIELD_INTEGER ), |
|
DEFINE_ARRAY( friendsName, FIELD_CHARACTER, MAX_PLAYER_NAME_LENGTH ), |
|
DEFINE_FIELD( fakeplayer, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( ishltv, FIELD_BOOLEAN ), |
|
#if defined( REPLAY_ENABLED ) |
|
DEFINE_FIELD( isreplay, FIELD_BOOLEAN ), |
|
#endif |
|
DEFINE_ARRAY( customFiles, FIELD_INTEGER, MAX_CUSTOM_FILES ), |
|
DEFINE_FIELD( filesDownloaded, FIELD_INTEGER ), |
|
END_BYTESWAP_DATADESC() |
|
|
|
static bool g_bRequestCacheUsedMaterials = false; |
|
void RequestCacheUsedMaterials() |
|
{ |
|
g_bRequestCacheUsedMaterials = true; |
|
} |
|
|
|
void ProcessCacheUsedMaterials() |
|
{ |
|
if ( !g_bRequestCacheUsedMaterials ) |
|
return; |
|
|
|
g_bRequestCacheUsedMaterials = false; |
|
if ( materials ) |
|
{ |
|
materials->CacheUsedMaterials(); |
|
} |
|
} |
|
|
|
// String tables |
|
INetworkStringTable *g_pStringTableParticleEffectNames = NULL; |
|
INetworkStringTable *g_StringTableEffectDispatch = NULL; |
|
INetworkStringTable *g_StringTableVguiScreen = NULL; |
|
INetworkStringTable *g_pStringTableMaterials = NULL; |
|
INetworkStringTable *g_pStringTableInfoPanel = NULL; |
|
INetworkStringTable *g_pStringTableClientSideChoreoScenes = NULL; |
|
INetworkStringTable *g_pStringTableServerMapCycle = NULL; |
|
|
|
#ifdef TF_CLIENT_DLL |
|
INetworkStringTable *g_pStringTableServerPopFiles = NULL; |
|
INetworkStringTable *g_pStringTableServerMapCycleMvM = NULL; |
|
#endif |
|
|
|
static CGlobalVarsBase dummyvars( true ); |
|
// So stuff that might reference gpGlobals during DLL initialization won't have a NULL pointer. |
|
// Once the engine calls Init on this DLL, this pointer gets assigned to the shared data in the engine |
|
CGlobalVarsBase *gpGlobals = &dummyvars; |
|
class CHudChat; |
|
class CViewRender; |
|
extern CViewRender g_DefaultViewRender; |
|
|
|
extern void StopAllRumbleEffects( void ); |
|
|
|
static C_BaseEntityClassList *s_pClassLists = NULL; |
|
C_BaseEntityClassList::C_BaseEntityClassList() |
|
{ |
|
m_pNextClassList = s_pClassLists; |
|
s_pClassLists = this; |
|
} |
|
C_BaseEntityClassList::~C_BaseEntityClassList() |
|
{ |
|
} |
|
|
|
// Any entities that want an OnDataChanged during simulation register for it here. |
|
class CDataChangedEvent |
|
{ |
|
public: |
|
CDataChangedEvent() = default; |
|
CDataChangedEvent( IClientNetworkable *ent, DataUpdateType_t updateType, int *pStoredEvent ) |
|
{ |
|
m_pEntity = ent; |
|
m_UpdateType = updateType; |
|
m_pStoredEvent = pStoredEvent; |
|
} |
|
|
|
IClientNetworkable *m_pEntity; |
|
DataUpdateType_t m_UpdateType; |
|
int *m_pStoredEvent; |
|
}; |
|
|
|
ISaveRestoreBlockHandler *GetEntitySaveRestoreBlockHandler(); |
|
ISaveRestoreBlockHandler *GetViewEffectsRestoreBlockHandler(); |
|
|
|
CUtlLinkedList<CDataChangedEvent, unsigned short> g_DataChangedEvents; |
|
ClientFrameStage_t g_CurFrameStage = FRAME_UNDEFINED; |
|
|
|
|
|
class IMoveHelper; |
|
|
|
void DispatchHudText( const char *pszName ); |
|
|
|
static ConVar s_CV_ShowParticleCounts("showparticlecounts", "0", 0, "Display number of particles drawn per frame"); |
|
static ConVar s_cl_team("cl_team", "default", FCVAR_USERINFO|FCVAR_ARCHIVE, "Default team when joining a game"); |
|
static ConVar s_cl_class("cl_class", "default", FCVAR_USERINFO|FCVAR_ARCHIVE, "Default class when joining a game"); |
|
|
|
#ifdef HL1MP_CLIENT_DLL |
|
static ConVar s_cl_load_hl1_content("cl_load_hl1_content", "0", FCVAR_ARCHIVE, "Mount the content from Half-Life: Source if possible"); |
|
#endif |
|
|
|
|
|
// Physics system |
|
bool g_bLevelInitialized; |
|
bool g_bTextMode = false; |
|
class IClientPurchaseInterfaceV2 *g_pClientPurchaseInterface = (class IClientPurchaseInterfaceV2 *)(&g_bTextMode + 156); |
|
|
|
static ConVar *g_pcv_ThreadMode = NULL; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: interface for gameui to modify voice bans |
|
//----------------------------------------------------------------------------- |
|
class CGameClientExports : public IGameClientExports |
|
{ |
|
public: |
|
// ingame voice manipulation |
|
bool IsPlayerGameVoiceMuted(int playerIndex) |
|
{ |
|
return GetClientVoiceMgr()->IsPlayerBlocked(playerIndex); |
|
} |
|
|
|
void MutePlayerGameVoice(int playerIndex) |
|
{ |
|
GetClientVoiceMgr()->SetPlayerBlockedState(playerIndex, true); |
|
} |
|
|
|
void UnmutePlayerGameVoice(int playerIndex) |
|
{ |
|
GetClientVoiceMgr()->SetPlayerBlockedState(playerIndex, false); |
|
} |
|
|
|
void OnGameUIActivated( void ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "gameui_activated" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEventClientSide( event ); |
|
} |
|
} |
|
|
|
void OnGameUIHidden( void ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "gameui_hidden" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEventClientSide( event ); |
|
} |
|
} |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [dwenger] Necessary for stats display |
|
//============================================================================= |
|
|
|
void CreateAchievementsPanel( vgui::Panel* pParent ) |
|
{ |
|
if (g_pAchievementsAndStatsInterface) |
|
{ |
|
g_pAchievementsAndStatsInterface->CreatePanel( pParent ); |
|
} |
|
} |
|
|
|
void DisplayAchievementPanel() |
|
{ |
|
if (g_pAchievementsAndStatsInterface) |
|
{ |
|
g_pAchievementsAndStatsInterface->DisplayPanel(); |
|
} |
|
} |
|
|
|
void ShutdownAchievementPanel() |
|
{ |
|
if (g_pAchievementsAndStatsInterface) |
|
{ |
|
g_pAchievementsAndStatsInterface->ReleasePanel(); |
|
} |
|
} |
|
|
|
int GetAchievementsPanelMinWidth( void ) const |
|
{ |
|
if ( g_pAchievementsAndStatsInterface ) |
|
{ |
|
return g_pAchievementsAndStatsInterface->GetAchievementsPanelMinWidth(); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
const char *GetHolidayString() |
|
{ |
|
return UTIL_GetActiveHolidayString(); |
|
} |
|
}; |
|
|
|
EXPOSE_SINGLE_INTERFACE( CGameClientExports, IGameClientExports, GAMECLIENTEXPORTS_INTERFACE_VERSION ); |
|
|
|
class CClientDLLSharedAppSystems : public IClientDLLSharedAppSystems |
|
{ |
|
public: |
|
CClientDLLSharedAppSystems() |
|
{ |
|
AddAppSystem( "soundemittersystem" DLL_EXT_STRING, SOUNDEMITTERSYSTEM_INTERFACE_VERSION ); |
|
AddAppSystem( "scenefilecache" DLL_EXT_STRING, SCENE_FILE_CACHE_INTERFACE_VERSION ); |
|
} |
|
|
|
virtual int Count() |
|
{ |
|
return m_Systems.Count(); |
|
} |
|
virtual char const *GetDllName( int idx ) |
|
{ |
|
return m_Systems[ idx ].m_pModuleName; |
|
} |
|
virtual char const *GetInterfaceName( int idx ) |
|
{ |
|
return m_Systems[ idx ].m_pInterfaceName; |
|
} |
|
private: |
|
void AddAppSystem( char const *moduleName, char const *interfaceName ) |
|
{ |
|
AppSystemInfo_t sys; |
|
sys.m_pModuleName = moduleName; |
|
sys.m_pInterfaceName = interfaceName; |
|
m_Systems.AddToTail( sys ); |
|
} |
|
|
|
CUtlVector< AppSystemInfo_t > m_Systems; |
|
}; |
|
|
|
EXPOSE_SINGLE_INTERFACE( CClientDLLSharedAppSystems, IClientDLLSharedAppSystems, CLIENT_DLL_SHARED_APPSYSTEMS ); |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Helper interface for voice. |
|
//----------------------------------------------------------------------------- |
|
class CHLVoiceStatusHelper : public IVoiceStatusHelper |
|
{ |
|
public: |
|
virtual void GetPlayerTextColor(int entindex, int color[3]) |
|
{ |
|
color[0] = color[1] = color[2] = 128; |
|
} |
|
|
|
virtual void UpdateCursorState() |
|
{ |
|
} |
|
|
|
virtual bool CanShowSpeakerLabels() |
|
{ |
|
return true; |
|
} |
|
}; |
|
static CHLVoiceStatusHelper g_VoiceStatusHelper; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Code to display which entities are having their bones setup each frame. |
|
//----------------------------------------------------------------------------- |
|
|
|
ConVar cl_ShowBoneSetupEnts( "cl_ShowBoneSetupEnts", "0", 0, "Show which entities are having their bones setup each frame." ); |
|
|
|
class CBoneSetupEnt |
|
{ |
|
public: |
|
char m_ModelName[128]; |
|
int m_Index; |
|
int m_Count; |
|
}; |
|
|
|
bool BoneSetupCompare( const CBoneSetupEnt &a, const CBoneSetupEnt &b ) |
|
{ |
|
return a.m_Index < b.m_Index; |
|
} |
|
|
|
CUtlRBTree<CBoneSetupEnt> g_BoneSetupEnts( BoneSetupCompare ); |
|
|
|
|
|
void TrackBoneSetupEnt( C_BaseAnimating *pEnt ) |
|
{ |
|
#ifdef _DEBUG |
|
if ( IsRetail() ) |
|
return; |
|
|
|
if ( !cl_ShowBoneSetupEnts.GetInt() ) |
|
return; |
|
|
|
CBoneSetupEnt ent; |
|
ent.m_Index = pEnt->entindex(); |
|
unsigned short i = g_BoneSetupEnts.Find( ent ); |
|
if ( i == g_BoneSetupEnts.InvalidIndex() ) |
|
{ |
|
Q_strncpy( ent.m_ModelName, modelinfo->GetModelName( pEnt->GetModel() ), sizeof( ent.m_ModelName ) ); |
|
ent.m_Count = 1; |
|
g_BoneSetupEnts.Insert( ent ); |
|
} |
|
else |
|
{ |
|
g_BoneSetupEnts[i].m_Count++; |
|
} |
|
#endif |
|
} |
|
|
|
void DisplayBoneSetupEnts() |
|
{ |
|
#ifdef _DEBUG |
|
if ( IsRetail() ) |
|
return; |
|
|
|
if ( !cl_ShowBoneSetupEnts.GetInt() ) |
|
return; |
|
|
|
unsigned short i; |
|
int nElements = 0; |
|
for ( i=g_BoneSetupEnts.FirstInorder(); i != g_BoneSetupEnts.LastInorder(); i=g_BoneSetupEnts.NextInorder( i ) ) |
|
++nElements; |
|
|
|
engine->Con_NPrintf( 0, "%d bone setup ents (name/count/entindex) ------------", nElements ); |
|
|
|
con_nprint_s printInfo; |
|
printInfo.time_to_live = -1; |
|
printInfo.fixed_width_font = true; |
|
printInfo.color[0] = printInfo.color[1] = printInfo.color[2] = 1; |
|
|
|
printInfo.index = 2; |
|
for ( i=g_BoneSetupEnts.FirstInorder(); i != g_BoneSetupEnts.LastInorder(); i=g_BoneSetupEnts.NextInorder( i ) ) |
|
{ |
|
CBoneSetupEnt *pEnt = &g_BoneSetupEnts[i]; |
|
|
|
if ( pEnt->m_Count >= 3 ) |
|
{ |
|
printInfo.color[0] = 1; |
|
printInfo.color[1] = printInfo.color[2] = 0; |
|
} |
|
else if ( pEnt->m_Count == 2 ) |
|
{ |
|
printInfo.color[0] = (float)200 / 255; |
|
printInfo.color[1] = (float)220 / 255; |
|
printInfo.color[2] = 0; |
|
} |
|
else |
|
{ |
|
printInfo.color[0] = printInfo.color[0] = printInfo.color[0] = 1; |
|
} |
|
engine->Con_NXPrintf( &printInfo, "%25s / %3d / %3d", pEnt->m_ModelName, pEnt->m_Count, pEnt->m_Index ); |
|
printInfo.index++; |
|
} |
|
|
|
g_BoneSetupEnts.RemoveAll(); |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: engine to client .dll interface |
|
//----------------------------------------------------------------------------- |
|
class CHLClient : public IBaseClientDLL |
|
{ |
|
public: |
|
CHLClient(); |
|
|
|
virtual int Init( CreateInterfaceFn appSystemFactory, CreateInterfaceFn physicsFactory, CGlobalVarsBase *pGlobals ); |
|
|
|
virtual void PostInit(); |
|
virtual void Shutdown( void ); |
|
|
|
virtual bool ReplayInit( CreateInterfaceFn fnReplayFactory ); |
|
virtual bool ReplayPostInit(); |
|
|
|
virtual void LevelInitPreEntity( const char *pMapName ); |
|
virtual void LevelInitPostEntity(); |
|
virtual void LevelShutdown( void ); |
|
|
|
virtual ClientClass *GetAllClasses( void ); |
|
|
|
virtual int HudVidInit( void ); |
|
virtual void HudProcessInput( bool bActive ); |
|
virtual void HudUpdate( bool bActive ); |
|
virtual void HudReset( void ); |
|
virtual void HudText( const char * message ); |
|
|
|
// Mouse Input Interfaces |
|
virtual void IN_ActivateMouse( void ); |
|
virtual void IN_DeactivateMouse( void ); |
|
virtual void IN_Accumulate( void ); |
|
virtual void IN_ClearStates( void ); |
|
virtual bool IN_IsKeyDown( const char *name, bool& isdown ); |
|
virtual void IN_OnMouseWheeled( int nDelta ); |
|
// Raw signal |
|
virtual int IN_KeyEvent( int eventcode, ButtonCode_t keynum, const char *pszCurrentBinding ); |
|
virtual void IN_SetSampleTime( float frametime ); |
|
// Create movement command |
|
virtual void CreateMove ( int sequence_number, float input_sample_frametime, bool active ); |
|
virtual void ExtraMouseSample( float frametime, bool active ); |
|
virtual bool WriteUsercmdDeltaToBuffer( bf_write *buf, int from, int to, bool isnewcommand ); |
|
virtual void EncodeUserCmdToBuffer( bf_write& buf, int slot ); |
|
virtual void DecodeUserCmdFromBuffer( bf_read& buf, int slot ); |
|
|
|
|
|
virtual void View_Render( vrect_t *rect ); |
|
virtual void RenderView( const CViewSetup &view, int nClearFlags, int whatToDraw ); |
|
virtual void View_Fade( ScreenFade_t *pSF ); |
|
|
|
virtual void SetCrosshairAngle( const QAngle& angle ); |
|
|
|
virtual void InitSprite( CEngineSprite *pSprite, const char *loadname ); |
|
virtual void ShutdownSprite( CEngineSprite *pSprite ); |
|
|
|
virtual int GetSpriteSize( void ) const; |
|
|
|
virtual void VoiceStatus( int entindex, qboolean bTalking ); |
|
|
|
virtual void InstallStringTableCallback( const char *tableName ); |
|
|
|
virtual void FrameStageNotify( ClientFrameStage_t curStage ); |
|
|
|
virtual bool DispatchUserMessage( int msg_type, bf_read &msg_data ); |
|
|
|
// Save/restore system hooks |
|
virtual CSaveRestoreData *SaveInit( int size ); |
|
virtual void SaveWriteFields( CSaveRestoreData *, const char *, void *, datamap_t *, typedescription_t *, int ); |
|
virtual void SaveReadFields( CSaveRestoreData *, const char *, void *, datamap_t *, typedescription_t *, int ); |
|
virtual void PreSave( CSaveRestoreData * ); |
|
virtual void Save( CSaveRestoreData * ); |
|
virtual void WriteSaveHeaders( CSaveRestoreData * ); |
|
virtual void ReadRestoreHeaders( CSaveRestoreData * ); |
|
virtual void Restore( CSaveRestoreData *, bool ); |
|
virtual void DispatchOnRestore(); |
|
virtual void WriteSaveGameScreenshot( const char *pFilename ); |
|
|
|
// Given a list of "S(wavname) S(wavname2)" tokens, look up the localized text and emit |
|
// the appropriate close caption if running with closecaption = 1 |
|
virtual void EmitSentenceCloseCaption( char const *tokenstream ); |
|
virtual void EmitCloseCaption( char const *captionname, float duration ); |
|
|
|
virtual CStandardRecvProxies* GetStandardRecvProxies(); |
|
|
|
virtual bool CanRecordDemo( char *errorMsg, int length ) const; |
|
|
|
virtual void OnDemoRecordStart( char const* pDemoBaseName ); |
|
virtual void OnDemoRecordStop(); |
|
virtual void OnDemoPlaybackStart( char const* pDemoBaseName ); |
|
virtual void OnDemoPlaybackStop(); |
|
|
|
virtual bool ShouldDrawDropdownConsole(); |
|
|
|
// Get client screen dimensions |
|
virtual int GetScreenWidth(); |
|
virtual int GetScreenHeight(); |
|
|
|
// save game screenshot writing |
|
virtual void WriteSaveGameScreenshotOfSize( const char *pFilename, int width, int height, bool bCreatePowerOf2Padded/*=false*/, bool bWriteVTF/*=false*/ ); |
|
|
|
// Gets the location of the player viewpoint |
|
virtual bool GetPlayerView( CViewSetup &playerView ); |
|
|
|
// Matchmaking |
|
virtual void SetupGameProperties( CUtlVector< XUSER_CONTEXT > &contexts, CUtlVector< XUSER_PROPERTY > &properties ); |
|
virtual uint GetPresenceID( const char *pIDName ); |
|
virtual const char *GetPropertyIdString( const uint id ); |
|
virtual void GetPropertyDisplayString( uint id, uint value, char *pOutput, int nBytes ); |
|
virtual void StartStatsReporting( HANDLE handle, bool bArbitrated ); |
|
|
|
virtual void InvalidateMdlCache(); |
|
|
|
virtual void ReloadFilesInList( IFileList *pFilesToReload ); |
|
|
|
// Let the client handle UI toggle - if this function returns false, the UI will toggle, otherwise it will not. |
|
virtual bool HandleUiToggle(); |
|
|
|
// Allow the console to be shown? |
|
virtual bool ShouldAllowConsole(); |
|
|
|
// Get renamed recv tables |
|
virtual CRenamedRecvTableInfo *GetRenamedRecvTableInfos(); |
|
|
|
// Get the mouthinfo for the sound being played inside UI panels |
|
virtual CMouthInfo *GetClientUIMouthInfo(); |
|
|
|
// Notify the client that a file has been received from the game server |
|
virtual void FileReceived( const char * fileName, unsigned int transferID ); |
|
|
|
virtual const char* TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName ); |
|
|
|
virtual void ClientAdjustStartSoundParams( struct StartSoundParams_t& params ); |
|
|
|
// Returns true if the disconnect command has been handled by the client |
|
virtual bool DisconnectAttempt( void ); |
|
public: |
|
void PrecacheMaterial( const char *pMaterialName ); |
|
|
|
virtual bool IsConnectedUserInfoChangeAllowed( IConVar *pCvar ); |
|
virtual void IN_TouchEvent( uint data, uint data2, uint data3, uint data4 ); |
|
|
|
private: |
|
void UncacheAllMaterials( ); |
|
void ResetStringTablePointers(); |
|
|
|
CUtlVector< IMaterial * > m_CachedMaterials; |
|
}; |
|
|
|
|
|
CHLClient gHLClient; |
|
IBaseClientDLL *clientdll = &gHLClient; |
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CHLClient, IBaseClientDLL, CLIENT_DLL_INTERFACE_VERSION, gHLClient ); |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Precaches a material |
|
//----------------------------------------------------------------------------- |
|
void PrecacheMaterial( const char *pMaterialName ) |
|
{ |
|
gHLClient.PrecacheMaterial( pMaterialName ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Converts a previously precached material into an index |
|
//----------------------------------------------------------------------------- |
|
int GetMaterialIndex( const char *pMaterialName ) |
|
{ |
|
if (pMaterialName) |
|
{ |
|
int nIndex = g_pStringTableMaterials->FindStringIndex( pMaterialName ); |
|
Assert( nIndex >= 0 ); |
|
if (nIndex >= 0) |
|
return nIndex; |
|
} |
|
|
|
// This is the invalid string index |
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Converts precached material indices into strings |
|
//----------------------------------------------------------------------------- |
|
const char *GetMaterialNameFromIndex( int nIndex ) |
|
{ |
|
if (nIndex != (g_pStringTableMaterials->GetMaxStrings() - 1)) |
|
{ |
|
return g_pStringTableMaterials->GetString( nIndex ); |
|
} |
|
else |
|
{ |
|
return NULL; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Precaches a particle system |
|
//----------------------------------------------------------------------------- |
|
void PrecacheParticleSystem( const char *pParticleSystemName ) |
|
{ |
|
g_pStringTableParticleEffectNames->AddString( false, pParticleSystemName ); |
|
g_pParticleSystemMgr->PrecacheParticleSystem( pParticleSystemName ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Converts a previously precached particle system into an index |
|
//----------------------------------------------------------------------------- |
|
int GetParticleSystemIndex( const char *pParticleSystemName ) |
|
{ |
|
if ( pParticleSystemName ) |
|
{ |
|
int nIndex = g_pStringTableParticleEffectNames->FindStringIndex( pParticleSystemName ); |
|
if ( nIndex != INVALID_STRING_INDEX ) |
|
return nIndex; |
|
DevWarning("Client: Missing precache for particle system \"%s\"!\n", pParticleSystemName ); |
|
} |
|
|
|
// This is the invalid string index |
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Converts precached particle system indices into strings |
|
//----------------------------------------------------------------------------- |
|
const char *GetParticleSystemNameFromIndex( int nIndex ) |
|
{ |
|
if ( nIndex < g_pStringTableParticleEffectNames->GetMaxStrings() ) |
|
return g_pStringTableParticleEffectNames->GetString( nIndex ); |
|
return "error"; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns true if host_thread_mode is set to non-zero (and engine is running in threaded mode) |
|
//----------------------------------------------------------------------------- |
|
bool IsEngineThreaded() |
|
{ |
|
if ( g_pcv_ThreadMode ) |
|
{ |
|
return g_pcv_ThreadMode->GetBool(); |
|
} |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Constructor |
|
//----------------------------------------------------------------------------- |
|
|
|
CHLClient::CHLClient() |
|
{ |
|
// Kinda bogus, but the logic in the engine is too convoluted to put it there |
|
g_bLevelInitialized = false; |
|
} |
|
|
|
|
|
extern IGameSystem *ViewportClientSystem(); |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
ISourceVirtualReality *g_pSourceVR = NULL; |
|
|
|
// Purpose: Called when the DLL is first loaded. |
|
// Input : engineFactory - |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CHLClient::Init( CreateInterfaceFn appSystemFactory, CreateInterfaceFn physicsFactory, CGlobalVarsBase *pGlobals ) |
|
{ |
|
InitCRTMemDebug(); |
|
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f ); |
|
|
|
|
|
#ifdef SIXENSE |
|
g_pSixenseInput = new SixenseInput; |
|
#endif |
|
|
|
// Hook up global variables |
|
gpGlobals = pGlobals; |
|
|
|
ConnectTier1Libraries( &appSystemFactory, 1 ); |
|
ConnectTier2Libraries( &appSystemFactory, 1 ); |
|
ConnectTier3Libraries( &appSystemFactory, 1 ); |
|
|
|
#ifndef NO_STEAM |
|
ClientSteamContext().Activate(); |
|
#endif |
|
|
|
// We aren't happy unless we get all of our interfaces. |
|
// please don't collapse this into one monolithic boolean expression (impossible to debug) |
|
if ( (engine = (IVEngineClient *)appSystemFactory( VENGINE_CLIENT_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (modelrender = (IVModelRender *)appSystemFactory( VENGINE_HUDMODEL_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (effects = (IVEfx *)appSystemFactory( VENGINE_EFFECTS_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (enginetrace = (IEngineTrace *)appSystemFactory( INTERFACEVERSION_ENGINETRACE_CLIENT, NULL )) == NULL ) |
|
return false; |
|
if ( (render = (IVRenderView *)appSystemFactory( VENGINE_RENDERVIEW_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (debugoverlay = (IVDebugOverlay *)appSystemFactory( VDEBUG_OVERLAY_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (datacache = (IDataCache*)appSystemFactory(DATACACHE_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( !mdlcache ) |
|
return false; |
|
if ( (modelinfo = (IVModelInfoClient *)appSystemFactory(VMODELINFO_CLIENT_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (enginevgui = (IEngineVGui *)appSystemFactory(VENGINE_VGUI_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (networkstringtable = (INetworkStringTableContainer *)appSystemFactory(INTERFACENAME_NETWORKSTRINGTABLECLIENT,NULL)) == NULL ) |
|
return false; |
|
if ( (partition = (ISpatialPartition *)appSystemFactory(INTERFACEVERSION_SPATIALPARTITION, NULL)) == NULL ) |
|
return false; |
|
if ( (shadowmgr = (IShadowMgr *)appSystemFactory(ENGINE_SHADOWMGR_INTERFACE_VERSION, NULL)) == NULL ) |
|
return false; |
|
if ( (staticpropmgr = (IStaticPropMgrClient *)appSystemFactory(INTERFACEVERSION_STATICPROPMGR_CLIENT, NULL)) == NULL ) |
|
return false; |
|
if ( (enginesound = (IEngineSound *)appSystemFactory(IENGINESOUND_CLIENT_INTERFACE_VERSION, NULL)) == NULL ) |
|
return false; |
|
if ( (filesystem = (IFileSystem *)appSystemFactory(FILESYSTEM_INTERFACE_VERSION, NULL)) == NULL ) |
|
return false; |
|
if ( (random = (IUniformRandomStream *)appSystemFactory(VENGINE_CLIENT_RANDOM_INTERFACE_VERSION, NULL)) == NULL ) |
|
return false; |
|
if ( (gameuifuncs = (IGameUIFuncs * )appSystemFactory( VENGINE_GAMEUIFUNCS_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( (gameeventmanager = (IGameEventManager2 *)appSystemFactory(INTERFACEVERSION_GAMEEVENTSMANAGER2,NULL)) == NULL ) |
|
return false; |
|
if ( (soundemitterbase = (ISoundEmitterSystemBase *)appSystemFactory(SOUNDEMITTERSYSTEM_INTERFACE_VERSION, NULL)) == NULL ) |
|
return false; |
|
if ( (inputsystem = (IInputSystem *)appSystemFactory(INPUTSYSTEM_INTERFACE_VERSION, NULL)) == NULL ) |
|
return false; |
|
if ( (scenefilecache = (ISceneFileCache *)appSystemFactory( SCENE_FILE_CACHE_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( IsX360() && (xboxsystem = (IXboxSystem *)appSystemFactory( XBOXSYSTEM_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( IsX360() && (matchmaking = (IMatchmaking *)appSystemFactory( VENGINE_MATCHMAKING_VERSION, NULL )) == NULL ) |
|
return false; |
|
#ifndef _XBOX |
|
if ( ( gamestatsuploader = (IUploadGameStats *)appSystemFactory( INTERFACEVERSION_UPLOADGAMESTATS, NULL )) == NULL ) |
|
return false; |
|
#endif |
|
|
|
#if defined( REPLAY_ENABLED ) |
|
if ( IsPC() && (g_pEngineReplay = (IEngineReplay *)appSystemFactory( ENGINE_REPLAY_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
if ( IsPC() && (g_pEngineClientReplay = (IEngineClientReplay *)appSystemFactory( ENGINE_REPLAY_CLIENT_INTERFACE_VERSION, NULL )) == NULL ) |
|
return false; |
|
#endif |
|
|
|
if (!g_pMatSystemSurface) |
|
return false; |
|
|
|
#ifdef WORKSHOP_IMPORT_ENABLED |
|
if ( !ConnectDataModel( appSystemFactory ) ) |
|
return false; |
|
if ( InitDataModel() != INIT_OK ) |
|
return false; |
|
InitFbx(); |
|
#endif |
|
|
|
// it's ok if this is NULL. That just means the sourcevr.dll wasn't found |
|
g_pSourceVR = (ISourceVirtualReality *)appSystemFactory(SOURCE_VIRTUAL_REALITY_INTERFACE_VERSION, NULL); |
|
|
|
factorylist_t factories; |
|
factories.appSystemFactory = appSystemFactory; |
|
factories.physicsFactory = physicsFactory; |
|
FactoryList_Store( factories ); |
|
|
|
// Yes, both the client and game .dlls will try to Connect, the soundemittersystem.dll will handle this gracefully |
|
if ( !soundemitterbase->Connect( appSystemFactory ) ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( CommandLine()->FindParm( "-textmode" ) ) |
|
g_bTextMode = true; |
|
|
|
if ( CommandLine()->FindParm( "-makedevshots" ) ) |
|
g_MakingDevShots = true; |
|
|
|
// Not fatal if the material system stub isn't around. |
|
materials_stub = (IMaterialSystemStub*)appSystemFactory( MATERIAL_SYSTEM_STUB_INTERFACE_VERSION, NULL ); |
|
|
|
if( !g_pMaterialSystemHardwareConfig ) |
|
return false; |
|
|
|
// Hook up the gaussian random number generator |
|
s_GaussianRandomStream.AttachToStream( random ); |
|
|
|
// Initialize the console variables. |
|
ConVar_Register( FCVAR_CLIENTDLL ); |
|
|
|
g_pcv_ThreadMode = g_pCVar->FindVar( "host_thread_mode" ); |
|
|
|
if (!Initializer::InitializeAllObjects()) |
|
return false; |
|
|
|
if (!ParticleMgr()->Init(MAX_TOTAL_PARTICLES, materials)) |
|
return false; |
|
|
|
|
|
if (!VGui_Startup( appSystemFactory )) |
|
return false; |
|
|
|
vgui::VGui_InitMatSysInterfacesList( "ClientDLL", &appSystemFactory, 1 ); |
|
|
|
// Add the client systems. |
|
|
|
// Client Leaf System has to be initialized first, since DetailObjectSystem uses it |
|
IGameSystem::Add( GameStringSystem() ); |
|
IGameSystem::Add( SoundEmitterSystem() ); |
|
IGameSystem::Add( ToolFrameworkClientSystem() ); |
|
IGameSystem::Add( ClientLeafSystem() ); |
|
IGameSystem::Add( DetailObjectSystem() ); |
|
IGameSystem::Add( ViewportClientSystem() ); |
|
IGameSystem::Add( ClientEffectPrecacheSystem() ); |
|
IGameSystem::Add( g_pClientShadowMgr ); |
|
IGameSystem::Add( g_pColorCorrectionMgr ); // NOTE: This must happen prior to ClientThinkList (color correction is updated there) |
|
IGameSystem::Add( ClientThinkList() ); |
|
IGameSystem::Add( ClientSoundscapeSystem() ); |
|
IGameSystem::Add( PerfVisualBenchmark() ); |
|
IGameSystem::Add( MumbleSystem() ); |
|
|
|
#if defined( TF_CLIENT_DLL ) |
|
IGameSystem::Add( CustomTextureToolCacheGameSystem() ); |
|
IGameSystem::Add( TFSharedContentManager() ); |
|
#endif |
|
|
|
#if defined( TF_CLIENT_DLL ) |
|
if ( g_AbuseReportMgr != NULL ) |
|
{ |
|
IGameSystem::Add( g_AbuseReportMgr ); |
|
} |
|
#endif |
|
|
|
#if defined( CLIENT_DLL ) && defined( COPY_CHECK_STRESSTEST ) |
|
IGameSystem::Add( GetPredictionCopyTester() ); |
|
#endif |
|
|
|
modemanager->Init( ); |
|
|
|
g_pClientMode->InitViewport(); |
|
|
|
gHUD.Init(); |
|
gTouch.Init(); |
|
|
|
g_pClientMode->Init(); |
|
|
|
if ( !IGameSystem::InitAllSystems() ) |
|
return false; |
|
|
|
g_pClientMode->Enable(); |
|
|
|
if ( !view ) |
|
{ |
|
view = ( IViewRender * )&g_DefaultViewRender; |
|
} |
|
|
|
view->Init(); |
|
vieweffects->Init(); |
|
|
|
C_BaseTempEntity::PrecacheTempEnts(); |
|
|
|
input->Init_All(); |
|
|
|
VGui_CreateGlobalPanels(); |
|
|
|
InitSmokeFogOverlay(); |
|
|
|
// Register user messages.. |
|
CUserMessageRegister::RegisterAll(); |
|
|
|
ClientVoiceMgr_Init(); |
|
|
|
// Embed voice status icons inside chat element |
|
{ |
|
vgui::VPANEL parent = enginevgui->GetPanel( PANEL_CLIENTDLL ); |
|
GetClientVoiceMgr()->Init( &g_VoiceStatusHelper, parent ); |
|
} |
|
|
|
if ( !PhysicsDLLInit( physicsFactory ) ) |
|
return false; |
|
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetEntitySaveRestoreBlockHandler() ); |
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetPhysSaveRestoreBlockHandler() ); |
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetViewEffectsRestoreBlockHandler() ); |
|
|
|
ClientWorldFactoryInit(); |
|
|
|
C_BaseAnimating::InitBoneSetupThreadPool(); |
|
|
|
#if defined( WIN32 ) && !defined( _X360 ) |
|
// NVNT connect haptics sytem |
|
ConnectHaptics(appSystemFactory); |
|
#endif |
|
#ifndef _X360 |
|
HookHapticMessages(); // Always hook the messages |
|
#endif |
|
|
|
return true; |
|
} |
|
|
|
bool CHLClient::ReplayInit( CreateInterfaceFn fnReplayFactory ) |
|
{ |
|
#if defined( REPLAY_ENABLED ) |
|
if ( !IsPC() ) |
|
return false; |
|
if ( (g_pReplay = (IReplaySystem *)fnReplayFactory( REPLAY_INTERFACE_VERSION, NULL ) ) == NULL ) |
|
return false; |
|
if ( (g_pClientReplayContext = g_pReplay->CL_GetContext()) == NULL ) |
|
return false; |
|
|
|
return true; |
|
#else |
|
return false; |
|
#endif |
|
} |
|
|
|
bool CHLClient::ReplayPostInit() |
|
{ |
|
#if defined( REPLAY_ENABLED ) |
|
if ( ( g_pReplayManager = g_pClientReplayContext->GetReplayManager() ) == NULL ) |
|
return false; |
|
if ( ( g_pReplayScreenshotManager = g_pClientReplayContext->GetScreenshotManager() ) == NULL ) |
|
return false; |
|
if ( ( g_pReplayPerformanceManager = g_pClientReplayContext->GetPerformanceManager() ) == NULL ) |
|
return false; |
|
if ( ( g_pReplayPerformanceController = g_pClientReplayContext->GetPerformanceController() ) == NULL ) |
|
return false; |
|
if ( ( g_pReplayMovieManager = g_pClientReplayContext->GetMovieManager() ) == NULL ) |
|
return false; |
|
return true; |
|
#else |
|
return false; |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called after client & server DLL are loaded and all systems initialized |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::PostInit() |
|
{ |
|
IGameSystem::PostInitAllSystems(); |
|
|
|
#ifdef SIXENSE |
|
// allow sixnese input to perform post-init operations |
|
g_pSixenseInput->PostInit(); |
|
#endif |
|
|
|
g_ClientVirtualReality.StartupComplete(); |
|
|
|
#ifdef HL1MP_CLIENT_DLL |
|
if ( s_cl_load_hl1_content.GetBool() && steamapicontext && steamapicontext->SteamApps() ) |
|
{ |
|
char szPath[ MAX_PATH*2 ]; |
|
int ccFolder= steamapicontext->SteamApps()->GetAppInstallDir( 280, szPath, sizeof(szPath) ); |
|
if ( ccFolder > 0 ) |
|
{ |
|
V_AppendSlash( szPath, sizeof(szPath) ); |
|
V_strncat( szPath, "hl1", sizeof( szPath ) ); |
|
|
|
g_pFullFileSystem->AddSearchPath( szPath, "HL1" ); |
|
g_pFullFileSystem->AddSearchPath( szPath, "GAME" ); |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when the client .dll is being dismissed |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::Shutdown( void ) |
|
{ |
|
if (g_pAchievementsAndStatsInterface) |
|
{ |
|
g_pAchievementsAndStatsInterface->ReleasePanel(); |
|
} |
|
|
|
#ifdef SIXENSE |
|
g_pSixenseInput->Shutdown(); |
|
delete g_pSixenseInput; |
|
g_pSixenseInput = NULL; |
|
#endif |
|
|
|
C_BaseAnimating::ShutdownBoneSetupThreadPool(); |
|
ClientWorldFactoryShutdown(); |
|
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetViewEffectsRestoreBlockHandler() ); |
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetPhysSaveRestoreBlockHandler() ); |
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetEntitySaveRestoreBlockHandler() ); |
|
|
|
ClientVoiceMgr_Shutdown(); |
|
|
|
Initializer::FreeAllObjects(); |
|
|
|
g_pClientMode->Disable(); |
|
g_pClientMode->Shutdown(); |
|
|
|
input->Shutdown_All(); |
|
C_BaseTempEntity::ClearDynamicTempEnts(); |
|
TermSmokeFogOverlay(); |
|
view->Shutdown(); |
|
g_pParticleSystemMgr->UncacheAllParticleSystems(); |
|
UncacheAllMaterials(); |
|
|
|
IGameSystem::ShutdownAllSystems(); |
|
|
|
gHUD.Shutdown(); |
|
VGui_Shutdown(); |
|
gTouch.Shutdown(); |
|
|
|
ParticleMgr()->Term(); |
|
|
|
ClearKeyValuesCache(); |
|
|
|
#ifndef NO_STEAM |
|
ClientSteamContext().Shutdown(); |
|
#endif |
|
|
|
#ifdef WORKSHOP_IMPORT_ENABLED |
|
ShutdownDataModel(); |
|
DisconnectDataModel(); |
|
ShutdownFbx(); |
|
#endif |
|
|
|
// This call disconnects the VGui libraries which we rely on later in the shutdown path, so don't do it |
|
// DisconnectTier3Libraries( ); |
|
DisconnectTier2Libraries( ); |
|
ConVar_Unregister(); |
|
DisconnectTier1Libraries( ); |
|
|
|
gameeventmanager = NULL; |
|
|
|
#if defined( WIN32 ) && !defined( _X360 ) |
|
// NVNT Disconnect haptics system |
|
DisconnectHaptics(); |
|
#endif |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Called when the game initializes |
|
// and whenever the vid_mode is changed |
|
// so the HUD can reinitialize itself. |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CHLClient::HudVidInit( void ) |
|
{ |
|
gHUD.VidInit(); |
|
|
|
GetClientVoiceMgr()->VidInit(); |
|
|
|
return 1; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Method used to allow the client to filter input messages before the |
|
// move record is transmitted to the server |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::HudProcessInput( bool bActive ) |
|
{ |
|
g_pClientMode->ProcessInput( bActive ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when shared data gets changed, allows dll to modify data |
|
// Input : bActive - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::HudUpdate( bool bActive ) |
|
{ |
|
float frametime = gpGlobals->frametime; |
|
|
|
#if defined( TF_CLIENT_DLL ) |
|
CRTime::UpdateRealTime(); |
|
#endif |
|
|
|
GetClientVoiceMgr()->Frame( frametime ); |
|
|
|
gHUD.UpdateHud( bActive ); |
|
|
|
{ |
|
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false ); |
|
IGameSystem::UpdateAllSystems( frametime ); |
|
} |
|
|
|
// run vgui animations |
|
vgui::GetAnimationController()->UpdateAnimations( engine->Time() ); |
|
|
|
hudlcd->SetGlobalStat( "(time_int)", VarArgs( "%d", (int)gpGlobals->curtime ) ); |
|
hudlcd->SetGlobalStat( "(time_float)", VarArgs( "%.2f", gpGlobals->curtime ) ); |
|
|
|
// I don't think this is necessary any longer, but I will leave it until |
|
// I can check into this further. |
|
C_BaseTempEntity::CheckDynamicTempEnts(); |
|
|
|
#ifdef SIXENSE |
|
// If we're not connected, update sixense so we can move the mouse cursor when in the menus |
|
if( !engine->IsConnected() || engine->IsPaused() ) |
|
{ |
|
g_pSixenseInput->SixenseFrame( 0, NULL ); |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called to restore to "non"HUD state. |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::HudReset( void ) |
|
{ |
|
gHUD.VidInit(); |
|
PhysicsReset(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called to add hud text message |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::HudText( const char * message ) |
|
{ |
|
DispatchHudText( message ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CHLClient::ShouldDrawDropdownConsole() |
|
{ |
|
#if defined( REPLAY_ENABLED ) |
|
extern ConVar hud_freezecamhide; |
|
extern bool IsTakingAFreezecamScreenshot(); |
|
|
|
if ( hud_freezecamhide.GetBool() && IsTakingAFreezecamScreenshot() ) |
|
{ |
|
return false; |
|
} |
|
#endif |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : ClientClass |
|
//----------------------------------------------------------------------------- |
|
ClientClass *CHLClient::GetAllClasses( void ) |
|
{ |
|
return g_pClientClassHead; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::IN_ActivateMouse( void ) |
|
{ |
|
input->ActivateMouse(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::IN_DeactivateMouse( void ) |
|
{ |
|
input->DeactivateMouse(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::IN_Accumulate ( void ) |
|
{ |
|
input->AccumulateMouse(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::IN_ClearStates ( void ) |
|
{ |
|
input->ClearStates(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Engine can query for particular keys |
|
// Input : *name - |
|
//----------------------------------------------------------------------------- |
|
bool CHLClient::IN_IsKeyDown( const char *name, bool& isdown ) |
|
{ |
|
kbutton_t *key = input->FindKey( name ); |
|
if ( !key ) |
|
{ |
|
return false; |
|
} |
|
|
|
isdown = ( key->state & 1 ) ? true : false; |
|
|
|
// Found the key by name |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Engine can issue a key event |
|
// Input : eventcode - |
|
// keynum - |
|
// *pszCurrentBinding - |
|
void CHLClient::IN_OnMouseWheeled( int nDelta ) |
|
{ |
|
#if defined( REPLAY_ENABLED ) |
|
CReplayPerformanceEditorPanel *pPerfEditor = ReplayUI_GetPerformanceEditor(); |
|
if ( pPerfEditor ) |
|
{ |
|
pPerfEditor->OnInGameMouseWheelEvent( nDelta ); |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Engine can issue a key event |
|
// Input : eventcode - |
|
// keynum - |
|
// *pszCurrentBinding - |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CHLClient::IN_KeyEvent( int eventcode, ButtonCode_t keynum, const char *pszCurrentBinding ) |
|
{ |
|
return input->KeyEvent( eventcode, keynum, pszCurrentBinding ); |
|
} |
|
|
|
void CHLClient::ExtraMouseSample( float frametime, bool active ) |
|
{ |
|
Assert( C_BaseEntity::IsAbsRecomputationsEnabled() ); |
|
Assert( C_BaseEntity::IsAbsQueriesValid() ); |
|
|
|
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false ); |
|
|
|
MDLCACHE_CRITICAL_SECTION(); |
|
input->ExtraMouseSample( frametime, active ); |
|
} |
|
|
|
void CHLClient::IN_SetSampleTime( float frametime ) |
|
{ |
|
input->Joystick_SetSampleTime( frametime ); |
|
input->IN_SetSampleTime( frametime ); |
|
|
|
#ifdef SIXENSE |
|
g_pSixenseInput->ResetFrameTime( frametime ); |
|
#endif |
|
} |
|
//----------------------------------------------------------------------------- |
|
// Purpose: Fills in usercmd_s structure based on current view angles and key/controller inputs |
|
// Input : frametime - timestamp for last frame |
|
// *cmd - the command to fill in |
|
// active - whether the user is fully connected to a server |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::CreateMove ( int sequence_number, float input_sample_frametime, bool active ) |
|
{ |
|
|
|
Assert( C_BaseEntity::IsAbsRecomputationsEnabled() ); |
|
Assert( C_BaseEntity::IsAbsQueriesValid() ); |
|
|
|
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false ); |
|
|
|
MDLCACHE_CRITICAL_SECTION(); |
|
input->CreateMove( sequence_number, input_sample_frametime, active ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *buf - |
|
// from - |
|
// to - |
|
//----------------------------------------------------------------------------- |
|
bool CHLClient::WriteUsercmdDeltaToBuffer( bf_write *buf, int from, int to, bool isnewcommand ) |
|
{ |
|
return input->WriteUsercmdDeltaToBuffer( buf, from, to, isnewcommand ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : buf - |
|
// buffersize - |
|
// slot - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::EncodeUserCmdToBuffer( bf_write& buf, int slot ) |
|
{ |
|
input->EncodeUserCmdToBuffer( buf, slot ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : buf - |
|
// buffersize - |
|
// slot - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::DecodeUserCmdFromBuffer( bf_read& buf, int slot ) |
|
{ |
|
input->DecodeUserCmdFromBuffer( buf, slot ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::View_Render( vrect_t *rect ) |
|
{ |
|
VPROF( "View_Render" ); |
|
|
|
// UNDONE: This gets hit at startup sometimes, investigate - will cause NaNs in calcs inside Render() |
|
if ( rect->width == 0 || rect->height == 0 ) |
|
return; |
|
|
|
view->Render( rect ); |
|
UpdatePerfStats(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Gets the location of the player viewpoint |
|
//----------------------------------------------------------------------------- |
|
bool CHLClient::GetPlayerView( CViewSetup &playerView ) |
|
{ |
|
playerView = *view->GetPlayerViewSetup(); |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Matchmaking |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::SetupGameProperties( CUtlVector< XUSER_CONTEXT > &contexts, CUtlVector< XUSER_PROPERTY > &properties ) |
|
{ |
|
presence->SetupGameProperties( contexts, properties ); |
|
} |
|
|
|
uint CHLClient::GetPresenceID( const char *pIDName ) |
|
{ |
|
return presence->GetPresenceID( pIDName ); |
|
} |
|
|
|
const char *CHLClient::GetPropertyIdString( const uint id ) |
|
{ |
|
return presence->GetPropertyIdString( id ); |
|
} |
|
|
|
void CHLClient::GetPropertyDisplayString( uint id, uint value, char *pOutput, int nBytes ) |
|
{ |
|
presence->GetPropertyDisplayString( id, value, pOutput, nBytes ); |
|
} |
|
|
|
void CHLClient::StartStatsReporting( HANDLE handle, bool bArbitrated ) |
|
{ |
|
presence->StartStatsReporting( handle, bArbitrated ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::InvalidateMdlCache() |
|
{ |
|
C_BaseAnimating *pAnimating; |
|
for ( C_BaseEntity *pEntity = ClientEntityList().FirstBaseEntity(); pEntity; pEntity = ClientEntityList().NextBaseEntity(pEntity) ) |
|
{ |
|
pAnimating = dynamic_cast<C_BaseAnimating *>(pEntity); |
|
if ( pAnimating ) |
|
{ |
|
pAnimating->InvalidateMdlCache(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pSF - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::View_Fade( ScreenFade_t *pSF ) |
|
{ |
|
if ( pSF != NULL ) |
|
vieweffects->Fade( *pSF ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Per level init |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::LevelInitPreEntity( char const* pMapName ) |
|
{ |
|
// HACK: Bogus, but the logic is too complicated in the engine |
|
if (g_bLevelInitialized) |
|
return; |
|
g_bLevelInitialized = true; |
|
|
|
input->LevelInit(); |
|
|
|
vieweffects->LevelInit(); |
|
|
|
//Tony; loadup per-map manifests. |
|
ParseParticleEffectsMap( pMapName, true ); |
|
|
|
// Tell mode manager that map is changing |
|
modemanager->LevelInit( pMapName ); |
|
ParticleMgr()->LevelInit(); |
|
|
|
hudlcd->SetGlobalStat( "(mapname)", pMapName ); |
|
|
|
C_BaseTempEntity::ClearDynamicTempEnts(); |
|
clienteffects->Flush(); |
|
view->LevelInit(); |
|
tempents->LevelInit(); |
|
ResetToneMapping(1.0); |
|
|
|
IGameSystem::LevelInitPreEntityAllSystems(pMapName); |
|
|
|
#ifdef USES_ECON_ITEMS |
|
GameItemSchema_t *pItemSchema = ItemSystem()->GetItemSchema(); |
|
if ( pItemSchema ) |
|
{ |
|
pItemSchema->BInitFromDelayedBuffer(); |
|
} |
|
#endif // USES_ECON_ITEMS |
|
|
|
ResetWindspeed(); |
|
|
|
#if !defined( NO_ENTITY_PREDICTION ) |
|
// don't do prediction if single player! |
|
// don't set direct because of FCVAR_USERINFO |
|
if ( gpGlobals->maxClients > 1 ) |
|
{ |
|
if ( !cl_predict->GetInt() ) |
|
{ |
|
engine->ClientCmd( "cl_predict 1" ); |
|
} |
|
} |
|
else |
|
{ |
|
if ( cl_predict->GetInt() ) |
|
{ |
|
engine->ClientCmd( "cl_predict 0" ); |
|
} |
|
} |
|
#endif |
|
|
|
// Check low violence settings for this map |
|
g_RagdollLVManager.SetLowViolence( pMapName ); |
|
|
|
gHUD.LevelInit(); |
|
|
|
#if defined( REPLAY_ENABLED ) |
|
// Initialize replay ragdoll recorder |
|
if ( !engine->IsPlayingDemo() ) |
|
{ |
|
CReplayRagdollRecorder::Instance().Init(); |
|
} |
|
#endif |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Per level init |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::LevelInitPostEntity( ) |
|
{ |
|
IGameSystem::LevelInitPostEntityAllSystems(); |
|
C_PhysPropClientside::RecreateAll(); |
|
internalCenterPrint->Clear(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Reset our global string table pointers |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::ResetStringTablePointers() |
|
{ |
|
g_pStringTableParticleEffectNames = NULL; |
|
g_StringTableEffectDispatch = NULL; |
|
g_StringTableVguiScreen = NULL; |
|
g_pStringTableMaterials = NULL; |
|
g_pStringTableInfoPanel = NULL; |
|
g_pStringTableClientSideChoreoScenes = NULL; |
|
g_pStringTableServerMapCycle = NULL; |
|
|
|
#ifdef TF_CLIENT_DLL |
|
g_pStringTableServerPopFiles = NULL; |
|
g_pStringTableServerMapCycleMvM = NULL; |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Per level de-init |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::LevelShutdown( void ) |
|
{ |
|
// HACK: Bogus, but the logic is too complicated in the engine |
|
if (!g_bLevelInitialized) |
|
return; |
|
|
|
g_bLevelInitialized = false; |
|
|
|
// Disable abs recomputations when everything is shutting down |
|
CBaseEntity::EnableAbsRecomputations( false ); |
|
|
|
// Level shutdown sequence. |
|
// First do the pre-entity shutdown of all systems |
|
IGameSystem::LevelShutdownPreEntityAllSystems(); |
|
|
|
C_PhysPropClientside::DestroyAll(); |
|
|
|
modemanager->LevelShutdown(); |
|
|
|
// Remove temporary entities before removing entities from the client entity list so that the te_* may |
|
// clean up before hand. |
|
tempents->LevelShutdown(); |
|
|
|
// Now release/delete the entities |
|
cl_entitylist->Release(); |
|
|
|
C_BaseEntityClassList *pClassList = s_pClassLists; |
|
while ( pClassList ) |
|
{ |
|
pClassList->LevelShutdown(); |
|
pClassList = pClassList->m_pNextClassList; |
|
} |
|
|
|
// Now do the post-entity shutdown of all systems |
|
IGameSystem::LevelShutdownPostEntityAllSystems(); |
|
|
|
view->LevelShutdown(); |
|
beams->ClearBeams(); |
|
ParticleMgr()->RemoveAllEffects(); |
|
|
|
StopAllRumbleEffects(); |
|
|
|
gHUD.LevelShutdown(); |
|
|
|
internalCenterPrint->Clear(); |
|
|
|
messagechars->Clear(); |
|
|
|
#ifndef TF_CLIENT_DLL |
|
// don't want to do this for TF2 because we have particle systems in our |
|
// character loadout screen that can be viewed when we're not connected to a server |
|
g_pParticleSystemMgr->UncacheAllParticleSystems(); |
|
#endif |
|
UncacheAllMaterials(); |
|
|
|
#ifdef _XBOX |
|
ReleaseRenderTargets(); |
|
#endif |
|
|
|
// string tables are cleared on disconnect from a server, so reset our global pointers to NULL |
|
ResetStringTablePointers(); |
|
|
|
#if defined( REPLAY_ENABLED ) |
|
// Shutdown the ragdoll recorder |
|
CReplayRagdollRecorder::Instance().Shutdown(); |
|
CReplayRagdollCache::Instance().Shutdown(); |
|
#endif |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Engine received crosshair offset ( autoaim ) |
|
// Input : angle - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::SetCrosshairAngle( const QAngle& angle ) |
|
{ |
|
CHudCrosshair *crosshair = GET_HUDELEMENT( CHudCrosshair ); |
|
if ( crosshair ) |
|
{ |
|
crosshair->SetCrosshairAngle( angle ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Helper to initialize sprite from .spr semaphor |
|
// Input : *pSprite - |
|
// *loadname - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::InitSprite( CEngineSprite *pSprite, const char *loadname ) |
|
{ |
|
if ( pSprite ) |
|
{ |
|
pSprite->Init( loadname ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pSprite - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::ShutdownSprite( CEngineSprite *pSprite ) |
|
{ |
|
if ( pSprite ) |
|
{ |
|
pSprite->Shutdown(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Tells engine how much space to allocate for sprite objects |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CHLClient::GetSpriteSize( void ) const |
|
{ |
|
return sizeof( CEngineSprite ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : entindex - |
|
// bTalking - |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::VoiceStatus( int entindex, qboolean bTalking ) |
|
{ |
|
GetClientVoiceMgr()->UpdateSpeakerStatus( entindex, !!bTalking ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Called when the string table for materials changes |
|
//----------------------------------------------------------------------------- |
|
void OnMaterialStringTableChanged( void *object, INetworkStringTable *stringTable, int stringNumber, const char *newString, void const *newData ) |
|
{ |
|
// Make sure this puppy is precached |
|
gHLClient.PrecacheMaterial( newString ); |
|
RequestCacheUsedMaterials(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Called when the string table for particle systems changes |
|
//----------------------------------------------------------------------------- |
|
void OnParticleSystemStringTableChanged( void *object, INetworkStringTable *stringTable, int stringNumber, const char *newString, void const *newData ) |
|
{ |
|
// Make sure this puppy is precached |
|
g_pParticleSystemMgr->PrecacheParticleSystem( newString ); |
|
RequestCacheUsedMaterials(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Called when the string table for VGUI changes |
|
//----------------------------------------------------------------------------- |
|
void OnVguiScreenTableChanged( void *object, INetworkStringTable *stringTable, int stringNumber, const char *newString, void const *newData ) |
|
{ |
|
// Make sure this puppy is precached |
|
vgui::Panel *pPanel = PanelMetaClassMgr()->CreatePanelMetaClass( newString, 100, NULL, NULL ); |
|
if ( pPanel ) |
|
PanelMetaClassMgr()->DestroyPanelMetaClass( pPanel ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Preload the string on the client (if single player it should already be in the cache from the server!!!) |
|
// Input : *object - |
|
// *stringTable - |
|
// stringNumber - |
|
// *newString - |
|
// *newData - |
|
//----------------------------------------------------------------------------- |
|
void OnSceneStringTableChanged( void *object, INetworkStringTable *stringTable, int stringNumber, const char *newString, void const *newData ) |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Hook up any callbacks here, the table definition has been parsed but |
|
// no data has been added yet |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::InstallStringTableCallback( const char *tableName ) |
|
{ |
|
// Here, cache off string table IDs |
|
if (!Q_strcasecmp(tableName, "VguiScreen")) |
|
{ |
|
// Look up the id |
|
g_StringTableVguiScreen = networkstringtable->FindTable( tableName ); |
|
|
|
// When the material list changes, we need to know immediately |
|
g_StringTableVguiScreen->SetStringChangedCallback( NULL, OnVguiScreenTableChanged ); |
|
} |
|
else if (!Q_strcasecmp(tableName, "Materials")) |
|
{ |
|
// Look up the id |
|
g_pStringTableMaterials = networkstringtable->FindTable( tableName ); |
|
|
|
// When the material list changes, we need to know immediately |
|
g_pStringTableMaterials->SetStringChangedCallback( NULL, OnMaterialStringTableChanged ); |
|
} |
|
else if ( !Q_strcasecmp( tableName, "EffectDispatch" ) ) |
|
{ |
|
g_StringTableEffectDispatch = networkstringtable->FindTable( tableName ); |
|
} |
|
else if ( !Q_strcasecmp( tableName, "InfoPanel" ) ) |
|
{ |
|
g_pStringTableInfoPanel = networkstringtable->FindTable( tableName ); |
|
} |
|
else if ( !Q_strcasecmp( tableName, "Scenes" ) ) |
|
{ |
|
g_pStringTableClientSideChoreoScenes = networkstringtable->FindTable( tableName ); |
|
g_pStringTableClientSideChoreoScenes->SetStringChangedCallback( NULL, OnSceneStringTableChanged ); |
|
} |
|
else if ( !Q_strcasecmp( tableName, "ParticleEffectNames" ) ) |
|
{ |
|
g_pStringTableParticleEffectNames = networkstringtable->FindTable( tableName ); |
|
networkstringtable->SetAllowClientSideAddString( g_pStringTableParticleEffectNames, true ); |
|
// When the particle system list changes, we need to know immediately |
|
g_pStringTableParticleEffectNames->SetStringChangedCallback( NULL, OnParticleSystemStringTableChanged ); |
|
} |
|
else if ( !Q_strcasecmp( tableName, "ServerMapCycle" ) ) |
|
{ |
|
g_pStringTableServerMapCycle = networkstringtable->FindTable( tableName ); |
|
} |
|
#ifdef TF_CLIENT_DLL |
|
else if ( !Q_strcasecmp( tableName, "ServerPopFiles" ) ) |
|
{ |
|
g_pStringTableServerPopFiles = networkstringtable->FindTable( tableName ); |
|
} |
|
else if ( !Q_strcasecmp( tableName, "ServerMapCycleMvM" ) ) |
|
{ |
|
g_pStringTableServerMapCycleMvM = networkstringtable->FindTable( tableName ); |
|
} |
|
#endif |
|
|
|
InstallStringTableCallback_GameRules(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Material precache |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::PrecacheMaterial( const char *pMaterialName ) |
|
{ |
|
Assert( pMaterialName ); |
|
|
|
int nLen = Q_strlen( pMaterialName ); |
|
char *pTempBuf = (char*)stackalloc( nLen + 1 ); |
|
memcpy( pTempBuf, pMaterialName, nLen + 1 ); |
|
char *pFound = Q_strstr( pTempBuf, ".vmt\0" ); |
|
if ( pFound ) |
|
{ |
|
*pFound = 0; |
|
} |
|
|
|
IMaterial *pMaterial = materials->FindMaterial( pTempBuf, TEXTURE_GROUP_PRECACHED ); |
|
if ( !IsErrorMaterial( pMaterial ) ) |
|
{ |
|
pMaterial->IncrementReferenceCount(); |
|
m_CachedMaterials.AddToTail( pMaterial ); |
|
} |
|
else |
|
{ |
|
if (IsOSX()) |
|
{ |
|
printf("\n ##### CHLClient::PrecacheMaterial could not find material %s (%s)", pMaterialName, pTempBuf ); |
|
} |
|
} |
|
} |
|
|
|
void CHLClient::UncacheAllMaterials( ) |
|
{ |
|
for (int i = m_CachedMaterials.Count(); --i >= 0; ) |
|
{ |
|
m_CachedMaterials[i]->DecrementReferenceCount(); |
|
} |
|
m_CachedMaterials.RemoveAll(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pszName - |
|
// iSize - |
|
// *pbuf - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CHLClient::DispatchUserMessage( int msg_type, bf_read &msg_data ) |
|
{ |
|
return usermessages->DispatchUserMessage( msg_type, msg_data ); |
|
} |
|
|
|
|
|
void SimulateEntities() |
|
{ |
|
VPROF_BUDGET("Client SimulateEntities", VPROF_BUDGETGROUP_CLIENT_SIM); |
|
|
|
// Service timer events (think functions). |
|
ClientThinkList()->PerformThinkFunctions(); |
|
|
|
// TODO: make an ISimulateable interface so C_BaseNetworkables can simulate? |
|
{ |
|
VPROF_("C_BaseEntity::Simulate", 1, VPROF_BUDGETGROUP_CLIENT_SIM, false, BUDGETFLAG_CLIENT); |
|
C_BaseEntityIterator iterator; |
|
C_BaseEntity *pEnt; |
|
while ( (pEnt = iterator.Next()) != NULL ) |
|
{ |
|
pEnt->Simulate(); |
|
} |
|
} |
|
} |
|
|
|
|
|
bool AddDataChangeEvent( IClientNetworkable *ent, DataUpdateType_t updateType, int *pStoredEvent ) |
|
{ |
|
VPROF( "AddDataChangeEvent" ); |
|
|
|
Assert( ent ); |
|
// Make sure we don't already have an event queued for this guy. |
|
if ( *pStoredEvent >= 0 ) |
|
{ |
|
Assert( g_DataChangedEvents[*pStoredEvent].m_pEntity == ent ); |
|
|
|
// DATA_UPDATE_CREATED always overrides DATA_UPDATE_CHANGED. |
|
if ( updateType == DATA_UPDATE_CREATED ) |
|
g_DataChangedEvents[*pStoredEvent].m_UpdateType = updateType; |
|
|
|
return false; |
|
} |
|
else |
|
{ |
|
*pStoredEvent = g_DataChangedEvents.AddToTail( CDataChangedEvent( ent, updateType, pStoredEvent ) ); |
|
return true; |
|
} |
|
} |
|
|
|
|
|
void ClearDataChangedEvent( int iStoredEvent ) |
|
{ |
|
if ( iStoredEvent != -1 ) |
|
g_DataChangedEvents.Remove( iStoredEvent ); |
|
} |
|
|
|
|
|
void ProcessOnDataChangedEvents() |
|
{ |
|
VPROF_("ProcessOnDataChangedEvents", 1, VPROF_BUDGETGROUP_CLIENT_SIM, false, BUDGETFLAG_CLIENT); |
|
FOR_EACH_LL( g_DataChangedEvents, i ) |
|
{ |
|
CDataChangedEvent *pEvent = &g_DataChangedEvents[i]; |
|
|
|
// Reset their stored event identifier. |
|
*pEvent->m_pStoredEvent = -1; |
|
|
|
// Send the event. |
|
IClientNetworkable *pNetworkable = pEvent->m_pEntity; |
|
pNetworkable->OnDataChanged( pEvent->m_UpdateType ); |
|
} |
|
|
|
g_DataChangedEvents.Purge(); |
|
} |
|
|
|
|
|
void UpdateClientRenderableInPVSStatus() |
|
{ |
|
// Vis for this view should already be setup at this point. |
|
|
|
// For each client-only entity, notify it if it's newly coming into the PVS. |
|
CUtlLinkedList<CClientEntityList::CPVSNotifyInfo,unsigned short> &theList = ClientEntityList().GetPVSNotifiers(); |
|
FOR_EACH_LL( theList, i ) |
|
{ |
|
CClientEntityList::CPVSNotifyInfo *pInfo = &theList[i]; |
|
|
|
if ( pInfo->m_InPVSStatus & INPVS_YES ) |
|
{ |
|
// Ok, this entity already thinks it's in the PVS. No need to notify it. |
|
// We need to set the INPVS_YES_THISFRAME flag if it's in this frame at all, so we |
|
// don't tell the entity it's not in the PVS anymore at the end of the frame. |
|
if ( !( pInfo->m_InPVSStatus & INPVS_THISFRAME ) ) |
|
{ |
|
if ( g_pClientLeafSystem->IsRenderableInPVS( pInfo->m_pRenderable ) ) |
|
{ |
|
pInfo->m_InPVSStatus |= INPVS_THISFRAME; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// This entity doesn't think it's in the PVS yet. If it is now in the PVS, let it know. |
|
if ( g_pClientLeafSystem->IsRenderableInPVS( pInfo->m_pRenderable ) ) |
|
{ |
|
pInfo->m_InPVSStatus |= ( INPVS_YES | INPVS_THISFRAME | INPVS_NEEDSNOTIFY ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void UpdatePVSNotifiers() |
|
{ |
|
MDLCACHE_CRITICAL_SECTION(); |
|
|
|
// At this point, all the entities that were rendered in the previous frame have INPVS_THISFRAME set |
|
// so we can tell the entities that aren't in the PVS anymore so. |
|
CUtlLinkedList<CClientEntityList::CPVSNotifyInfo,unsigned short> &theList = ClientEntityList().GetPVSNotifiers(); |
|
FOR_EACH_LL( theList, i ) |
|
{ |
|
CClientEntityList::CPVSNotifyInfo *pInfo = &theList[i]; |
|
|
|
// If this entity thinks it's in the PVS, but it wasn't in the PVS this frame, tell it so. |
|
if ( pInfo->m_InPVSStatus & INPVS_YES ) |
|
{ |
|
if ( pInfo->m_InPVSStatus & INPVS_THISFRAME ) |
|
{ |
|
if ( pInfo->m_InPVSStatus & INPVS_NEEDSNOTIFY ) |
|
{ |
|
pInfo->m_pNotify->OnPVSStatusChanged( true ); |
|
} |
|
// Clear it for the next time around. |
|
pInfo->m_InPVSStatus &= ~( INPVS_THISFRAME | INPVS_NEEDSNOTIFY ); |
|
} |
|
else |
|
{ |
|
pInfo->m_InPVSStatus &= ~INPVS_YES; |
|
pInfo->m_pNotify->OnPVSStatusChanged( false ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
void OnRenderStart() |
|
{ |
|
VPROF( "OnRenderStart" ); |
|
MDLCACHE_CRITICAL_SECTION(); |
|
MDLCACHE_COARSE_LOCK(); |
|
|
|
#ifdef PORTAL |
|
g_pPortalRender->UpdatePortalPixelVisibility(); //updating this one or two lines before querying again just isn't cutting it. Update as soon as it's cheap to do so. |
|
#endif |
|
|
|
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, true ); |
|
C_BaseEntity::SetAbsQueriesValid( false ); |
|
|
|
Rope_ResetCounters(); |
|
|
|
// Interpolate server entities and move aiments. |
|
{ |
|
PREDICTION_TRACKVALUECHANGESCOPE( "interpolation" ); |
|
C_BaseEntity::InterpolateServerEntities(); |
|
} |
|
|
|
{ |
|
// vprof node for this bloc of math |
|
VPROF( "OnRenderStart: dirty bone caches"); |
|
// Invalidate any bone information. |
|
C_BaseAnimating::InvalidateBoneCaches(); |
|
|
|
C_BaseEntity::SetAbsQueriesValid( true ); |
|
C_BaseEntity::EnableAbsRecomputations( true ); |
|
|
|
// Enable access to all model bones except view models. |
|
// This is necessary for aim-ent computation to occur properly |
|
C_BaseAnimating::PushAllowBoneAccess( true, false, "OnRenderStart->CViewRender::SetUpView" ); // pops in CViewRender::SetUpView |
|
|
|
// FIXME: This needs to be done before the player moves; it forces |
|
// aiments the player may be attached to to forcibly update their position |
|
C_BaseEntity::MarkAimEntsDirty(); |
|
} |
|
|
|
// Make sure the camera simulation happens before OnRenderStart, where it's used. |
|
// NOTE: the only thing that happens in CAM_Think is thirdperson related code. |
|
input->CAM_Think(); |
|
|
|
// This will place the player + the view models + all parent |
|
// entities at the correct abs position so that their attachment points |
|
// are at the correct location |
|
view->OnRenderStart(); |
|
|
|
RopeManager()->OnRenderStart(); |
|
|
|
// This will place all entities in the correct position in world space and in the KD-tree |
|
C_BaseAnimating::UpdateClientSideAnimations(); |
|
|
|
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false ); |
|
|
|
// Process OnDataChanged events. |
|
ProcessOnDataChangedEvents(); |
|
|
|
// Reset the overlay alpha. Entities can change the state of this in their think functions. |
|
g_SmokeFogOverlayAlpha = 0; |
|
|
|
// This must occur prior to SimulatEntities, |
|
// which is where the client thinks for c_colorcorrection + c_colorcorrectionvolumes |
|
// update the color correction weights. |
|
// FIXME: The place where IGameSystem::Update is called should be in here |
|
// so we don't have to explicitly call ResetColorCorrectionWeights + SimulateEntities, etc. |
|
g_pColorCorrectionMgr->ResetColorCorrectionWeights(); |
|
|
|
// Simulate all the entities. |
|
SimulateEntities(); |
|
PhysicsSimulate(); |
|
|
|
C_BaseAnimating::ThreadedBoneSetup(); |
|
|
|
{ |
|
VPROF_("Client TempEnts", 0, VPROF_BUDGETGROUP_CLIENT_SIM, false, BUDGETFLAG_CLIENT); |
|
// This creates things like temp entities. |
|
engine->FireEvents(); |
|
|
|
// Update temp entities |
|
tempents->Update(); |
|
|
|
// Update temp ent beams... |
|
beams->UpdateTempEntBeams(); |
|
|
|
// Lock the frame from beam additions |
|
SetBeamCreationAllowed( false ); |
|
} |
|
|
|
// Update particle effects (eventually, the effects should use Simulate() instead of having |
|
// their own update system). |
|
{ |
|
// Enable FP exceptions here when FP_EXCEPTIONS_ENABLED is defined, |
|
// to help track down bad math. |
|
FPExceptionEnabler enableExceptions; |
|
VPROF_BUDGET( "ParticleMgr()->Simulate", VPROF_BUDGETGROUP_PARTICLE_SIMULATION ); |
|
ParticleMgr()->Simulate( gpGlobals->frametime ); |
|
} |
|
|
|
// Now that the view model's position is setup and aiments are marked dirty, update |
|
// their positions so they're in the leaf system correctly. |
|
C_BaseEntity::CalcAimEntPositions(); |
|
|
|
// For entities marked for recording, post bone messages to IToolSystems |
|
if ( ToolsEnabled() ) |
|
{ |
|
C_BaseEntity::ToolRecordEntities(); |
|
} |
|
|
|
#if defined( REPLAY_ENABLED ) |
|
// This will record any ragdolls if Replay mode is enabled on the server |
|
CReplayRagdollRecorder::Instance().Think(); |
|
CReplayRagdollCache::Instance().Think(); |
|
#endif |
|
|
|
// Finally, link all the entities into the leaf system right before rendering. |
|
C_BaseEntity::AddVisibleEntities(); |
|
} |
|
|
|
|
|
void OnRenderEnd() |
|
{ |
|
// Disallow access to bones (access is enabled in CViewRender::SetUpView). |
|
C_BaseAnimating::PopBoneAccess( "CViewRender::SetUpView->OnRenderEnd" ); |
|
|
|
UpdatePVSNotifiers(); |
|
|
|
DisplayBoneSetupEnts(); |
|
} |
|
|
|
|
|
|
|
void CHLClient::FrameStageNotify( ClientFrameStage_t curStage ) |
|
{ |
|
g_CurFrameStage = curStage; |
|
|
|
switch( curStage ) |
|
{ |
|
default: |
|
break; |
|
|
|
case FRAME_RENDER_START: |
|
{ |
|
VPROF( "CHLClient::FrameStageNotify FRAME_RENDER_START" ); |
|
|
|
// Last thing before rendering, run simulation. |
|
OnRenderStart(); |
|
} |
|
break; |
|
|
|
case FRAME_RENDER_END: |
|
{ |
|
VPROF( "CHLClient::FrameStageNotify FRAME_RENDER_END" ); |
|
OnRenderEnd(); |
|
|
|
PREDICTION_SPEWVALUECHANGES(); |
|
} |
|
break; |
|
|
|
case FRAME_NET_UPDATE_START: |
|
{ |
|
VPROF( "CHLClient::FrameStageNotify FRAME_NET_UPDATE_START" ); |
|
// disabled all recomputations while we update entities |
|
C_BaseEntity::EnableAbsRecomputations( false ); |
|
C_BaseEntity::SetAbsQueriesValid( false ); |
|
Interpolation_SetLastPacketTimeStamp( engine->GetLastTimeStamp() ); |
|
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, true ); |
|
|
|
PREDICTION_STARTTRACKVALUE( "netupdate" ); |
|
} |
|
break; |
|
case FRAME_NET_UPDATE_END: |
|
{ |
|
ProcessCacheUsedMaterials(); |
|
|
|
// reenable abs recomputation since now all entities have been updated |
|
C_BaseEntity::EnableAbsRecomputations( true ); |
|
C_BaseEntity::SetAbsQueriesValid( true ); |
|
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false ); |
|
|
|
PREDICTION_ENDTRACKVALUE(); |
|
} |
|
break; |
|
case FRAME_NET_UPDATE_POSTDATAUPDATE_START: |
|
{ |
|
VPROF( "CHLClient::FrameStageNotify FRAME_NET_UPDATE_POSTDATAUPDATE_START" ); |
|
PREDICTION_STARTTRACKVALUE( "postdataupdate" ); |
|
} |
|
break; |
|
case FRAME_NET_UPDATE_POSTDATAUPDATE_END: |
|
{ |
|
VPROF( "CHLClient::FrameStageNotify FRAME_NET_UPDATE_POSTDATAUPDATE_END" ); |
|
PREDICTION_ENDTRACKVALUE(); |
|
// Let prediction copy off pristine data |
|
prediction->PostEntityPacketReceived(); |
|
HLTVCamera()->PostEntityPacketReceived(); |
|
#if defined( REPLAY_ENABLED ) |
|
ReplayCamera()->PostEntityPacketReceived(); |
|
#endif |
|
} |
|
break; |
|
case FRAME_START: |
|
{ |
|
// Mark the frame as open for client fx additions |
|
SetFXCreationAllowed( true ); |
|
SetBeamCreationAllowed( true ); |
|
C_BaseEntity::CheckCLInterpChanged(); |
|
} |
|
break; |
|
} |
|
} |
|
|
|
CSaveRestoreData *SaveInit( int size ); |
|
|
|
// Save/restore system hooks |
|
CSaveRestoreData *CHLClient::SaveInit( int size ) |
|
{ |
|
return ::SaveInit(size); |
|
} |
|
|
|
void CHLClient::SaveWriteFields( CSaveRestoreData *pSaveData, const char *pname, void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldCount ) |
|
{ |
|
CSave saveHelper( pSaveData ); |
|
saveHelper.WriteFields( pname, pBaseData, pMap, pFields, fieldCount ); |
|
} |
|
|
|
void CHLClient::SaveReadFields( CSaveRestoreData *pSaveData, const char *pname, void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldCount ) |
|
{ |
|
CRestore restoreHelper( pSaveData ); |
|
restoreHelper.ReadFields( pname, pBaseData, pMap, pFields, fieldCount ); |
|
} |
|
|
|
void CHLClient::PreSave( CSaveRestoreData *s ) |
|
{ |
|
g_pGameSaveRestoreBlockSet->PreSave( s ); |
|
} |
|
|
|
void CHLClient::Save( CSaveRestoreData *s ) |
|
{ |
|
CSave saveHelper( s ); |
|
g_pGameSaveRestoreBlockSet->Save( &saveHelper ); |
|
} |
|
|
|
void CHLClient::WriteSaveHeaders( CSaveRestoreData *s ) |
|
{ |
|
CSave saveHelper( s ); |
|
g_pGameSaveRestoreBlockSet->WriteSaveHeaders( &saveHelper ); |
|
g_pGameSaveRestoreBlockSet->PostSave(); |
|
} |
|
|
|
void CHLClient::ReadRestoreHeaders( CSaveRestoreData *s ) |
|
{ |
|
CRestore restoreHelper( s ); |
|
g_pGameSaveRestoreBlockSet->PreRestore(); |
|
g_pGameSaveRestoreBlockSet->ReadRestoreHeaders( &restoreHelper ); |
|
} |
|
|
|
void CHLClient::Restore( CSaveRestoreData *s, bool b ) |
|
{ |
|
CRestore restore(s); |
|
g_pGameSaveRestoreBlockSet->Restore( &restore, b ); |
|
g_pGameSaveRestoreBlockSet->PostRestore(); |
|
} |
|
|
|
static CUtlVector<EHANDLE> g_RestoredEntities; |
|
|
|
void AddRestoredEntity( C_BaseEntity *pEntity ) |
|
{ |
|
if ( !pEntity ) |
|
return; |
|
|
|
g_RestoredEntities.AddToTail( EHANDLE(pEntity) ); |
|
} |
|
|
|
void CHLClient::DispatchOnRestore() |
|
{ |
|
for ( int i = 0; i < g_RestoredEntities.Count(); i++ ) |
|
{ |
|
if ( g_RestoredEntities[i] != NULL ) |
|
{ |
|
MDLCACHE_CRITICAL_SECTION(); |
|
g_RestoredEntities[i]->OnRestore(); |
|
} |
|
} |
|
g_RestoredEntities.RemoveAll(); |
|
} |
|
|
|
void CHLClient::WriteSaveGameScreenshot( const char *pFilename ) |
|
{ |
|
view->WriteSaveGameScreenshot( pFilename ); |
|
} |
|
|
|
// Given a list of "S(wavname) S(wavname2)" tokens, look up the localized text and emit |
|
// the appropriate close caption if running with closecaption = 1 |
|
void CHLClient::EmitSentenceCloseCaption( char const *tokenstream ) |
|
{ |
|
extern ConVar closecaption; |
|
|
|
if ( !closecaption.GetBool() ) |
|
return; |
|
|
|
CHudCloseCaption *hudCloseCaption = GET_HUDELEMENT( CHudCloseCaption ); |
|
if ( hudCloseCaption ) |
|
{ |
|
hudCloseCaption->ProcessSentenceCaptionStream( tokenstream ); |
|
} |
|
} |
|
|
|
|
|
void CHLClient::EmitCloseCaption( char const *captionname, float duration ) |
|
{ |
|
extern ConVar closecaption; |
|
|
|
if ( !closecaption.GetBool() ) |
|
return; |
|
|
|
CHudCloseCaption *hudCloseCaption = GET_HUDELEMENT( CHudCloseCaption ); |
|
if ( hudCloseCaption ) |
|
{ |
|
hudCloseCaption->ProcessCaption( captionname, duration ); |
|
} |
|
} |
|
|
|
CStandardRecvProxies* CHLClient::GetStandardRecvProxies() |
|
{ |
|
return &g_StandardRecvProxies; |
|
} |
|
|
|
bool CHLClient::CanRecordDemo( char *errorMsg, int length ) const |
|
{ |
|
if ( GetClientModeNormal() ) |
|
{ |
|
return GetClientModeNormal()->CanRecordDemo( errorMsg, length ); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
void CHLClient::OnDemoRecordStart( char const* pDemoBaseName ) |
|
{ |
|
} |
|
|
|
void CHLClient::OnDemoRecordStop() |
|
{ |
|
} |
|
|
|
void CHLClient::OnDemoPlaybackStart( char const* pDemoBaseName ) |
|
{ |
|
#if defined( REPLAY_ENABLED ) |
|
// Load any ragdoll override frames from disk |
|
char szRagdollFile[MAX_OSPATH]; |
|
V_snprintf( szRagdollFile, sizeof(szRagdollFile), "%s.dmx", pDemoBaseName ); |
|
CReplayRagdollCache::Instance().Init( szRagdollFile ); |
|
#endif |
|
} |
|
|
|
void CHLClient::OnDemoPlaybackStop() |
|
{ |
|
#ifdef DEMOPOLISH_ENABLED |
|
if ( DemoPolish_GetController().m_bInit ) |
|
{ |
|
DemoPolish_GetController().Shutdown(); |
|
} |
|
#endif |
|
|
|
#if defined( REPLAY_ENABLED ) |
|
CReplayRagdollCache::Instance().Shutdown(); |
|
#endif |
|
} |
|
|
|
int CHLClient::GetScreenWidth() |
|
{ |
|
return ScreenWidth(); |
|
} |
|
|
|
int CHLClient::GetScreenHeight() |
|
{ |
|
return ScreenHeight(); |
|
} |
|
|
|
// NEW INTERFACES |
|
// save game screenshot writing |
|
void CHLClient::WriteSaveGameScreenshotOfSize( const char *pFilename, int width, int height, bool bCreatePowerOf2Padded/*=false*/, |
|
bool bWriteVTF/*=false*/ ) |
|
{ |
|
view->WriteSaveGameScreenshotOfSize( pFilename, width, height, bCreatePowerOf2Padded, bWriteVTF ); |
|
} |
|
|
|
// See RenderViewInfo_t |
|
void CHLClient::RenderView( const CViewSetup &setup, int nClearFlags, int whatToDraw ) |
|
{ |
|
VPROF("RenderView"); |
|
view->RenderView( setup, nClearFlags, whatToDraw ); |
|
} |
|
|
|
void ReloadSoundEntriesInList( IFileList *pFilesToReload ); |
|
|
|
//----------------------------------------------------------------------------- |
|
// For sv_pure mode. The filesystem figures out which files the client needs to reload to be "pure" ala the server's preferences. |
|
//----------------------------------------------------------------------------- |
|
void CHLClient::ReloadFilesInList( IFileList *pFilesToReload ) |
|
{ |
|
ReloadParticleEffectsInList( pFilesToReload ); |
|
ReloadSoundEntriesInList( pFilesToReload ); |
|
} |
|
|
|
bool CHLClient::HandleUiToggle() |
|
{ |
|
#if defined( REPLAY_ENABLED ) |
|
if ( !g_pEngineReplay || !g_pEngineReplay->IsSupportedModAndPlatform() ) |
|
return false; |
|
|
|
CReplayPerformanceEditorPanel *pEditor = ReplayUI_GetPerformanceEditor(); |
|
if ( !pEditor ) |
|
return false; |
|
|
|
pEditor->HandleUiToggle(); |
|
|
|
return true; |
|
|
|
#else |
|
return false; |
|
#endif |
|
} |
|
|
|
bool CHLClient::ShouldAllowConsole() |
|
{ |
|
return true; |
|
} |
|
|
|
CRenamedRecvTableInfo *CHLClient::GetRenamedRecvTableInfos() |
|
{ |
|
return g_pRenamedRecvTableInfoHead; |
|
} |
|
|
|
CMouthInfo g_ClientUIMouth; |
|
// Get the mouthinfo for the sound being played inside UI panels |
|
CMouthInfo *CHLClient::GetClientUIMouthInfo() |
|
{ |
|
return &g_ClientUIMouth; |
|
} |
|
|
|
void CHLClient::FileReceived( const char * fileName, unsigned int transferID ) |
|
{ |
|
if ( g_pGameRules ) |
|
{ |
|
g_pGameRules->OnFileReceived( fileName, transferID ); |
|
} |
|
} |
|
|
|
void CHLClient::ClientAdjustStartSoundParams( StartSoundParams_t& params ) |
|
{ |
|
#ifdef TF_CLIENT_DLL |
|
CBaseEntity *pEntity = ClientEntityList().GetEnt( params.soundsource ); |
|
|
|
// A player speaking |
|
if ( params.entchannel == CHAN_VOICE && GameRules() && pEntity && pEntity->IsPlayer() ) |
|
{ |
|
// Use high-pitched voices for other players if the local player has an item that allows them to hear it (Pyro Goggles) |
|
if ( !GameRules()->IsLocalPlayer( params.soundsource ) && IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) ) |
|
{ |
|
params.pitch *= 1.3f; |
|
} |
|
// Halloween voice futzery? |
|
else |
|
{ |
|
float flHeadScale = 1.f; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pEntity, flHeadScale, head_scale ); |
|
|
|
int iHalloweenVoiceSpell = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pEntity, iHalloweenVoiceSpell, halloween_voice_modulation ); |
|
if ( iHalloweenVoiceSpell > 0 ) |
|
{ |
|
params.pitch *= 0.8f; |
|
} |
|
else if( flHeadScale != 1.f ) |
|
{ |
|
// Big head, deep voice |
|
if( flHeadScale > 1.f ) |
|
{ |
|
params.pitch *= 0.8f; |
|
} |
|
else // Small head, high voice |
|
{ |
|
params.pitch *= 1.3f; |
|
} |
|
} |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
const char* CHLClient::TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName ) |
|
{ |
|
if ( !GameRules() ) |
|
return pchEffectName; |
|
|
|
return GameRules()->TranslateEffectForVisionFilter( pchEffectType, pchEffectName ); |
|
} |
|
|
|
bool CHLClient::DisconnectAttempt( void ) |
|
{ |
|
bool bRet = false; |
|
|
|
#if defined( TF_CLIENT_DLL ) |
|
bRet = HandleDisconnectAttempt(); |
|
#endif |
|
|
|
return bRet; |
|
} |
|
|
|
bool CHLClient::IsConnectedUserInfoChangeAllowed( IConVar *pCvar ) |
|
{ |
|
return GameRules() ? GameRules()->IsConnectedUserInfoChangeAllowed( NULL ) : true; |
|
} |
|
|
|
#ifndef NO_STEAM |
|
|
|
CSteamID GetSteamIDForPlayerIndex( int iPlayerIndex ) |
|
{ |
|
player_info_t pi; |
|
if ( steamapicontext && steamapicontext->SteamUtils() ) |
|
{ |
|
if ( engine->GetPlayerInfo( iPlayerIndex, &pi ) ) |
|
{ |
|
if ( pi.friendsID ) |
|
{ |
|
return CSteamID( pi.friendsID, 1, steamapicontext->SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual ); |
|
} |
|
} |
|
} |
|
return CSteamID(); |
|
} |
|
|
|
#endif |
|
|
|
|
|
void CHLClient::IN_TouchEvent( uint data, uint data2, uint data3, uint data4 ) |
|
{ |
|
if( enginevgui->IsGameUIVisible() ) |
|
return; |
|
|
|
touch_event_t ev; |
|
|
|
ev.type = data & 0xFFFF; |
|
ev.fingerid = (data >> 16) & 0xFFFF; |
|
ev.x = (double)((data2 >> 16) & 0xFFFF) / 0xFFFF; |
|
ev.y = (double)(data2 & 0xFFFF) / 0xFFFF; |
|
|
|
union{uint i;float f;} ifconv; |
|
ifconv.i = data3; |
|
ev.dx = ifconv.f; |
|
|
|
ifconv.i = data4; |
|
ev.dy = ifconv.f; |
|
|
|
gTouch.ProcessEvent( &ev ); |
|
}
|
|
|