//======= Copyright (c) 1996-2009, Valve Corporation, All rights reserved. ====== // // //=============================================================================== #include "cbase.h" #include #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 "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 "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 "vstdlib/jobthread.h" #include "gamerules_register.h" #include "game/client/iviewport.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 "tier3/tier3.h" #include "avi/iavi.h" #include "ihudlcd.h" #include "toolframework_client.h" #include "hltvcamera.h" #if defined( REPLAY_ENABLED ) #include "replaycamera.h" #include "replay_ragdoll.h" #include "replay_ragdoll.h" #include "qlimits.h" #include "engine/ireplayhistorymanager.h" #endif #include "ixboxsystem.h" #include "matchmaking/imatchframework.h" #include "cdll_bounded_cvars.h" #include "matsys_controls/matsyscontrols.h" #include "GameStats.h" #include "videocfg/videocfg.h" #include "tier2/tier2_logging.h" #include "vscript/ivscript.h" #include "activitylist.h" #include "eventlist.h" #ifdef GAMEUI_UISYSTEM2_ENABLED #include "gameui.h" #endif #ifdef GAMEUI_EMBEDDED #if defined( SWARM_DLL ) #include "swarm/gameui/swarm/basemodpanel.h" #else #error "GAMEUI_EMBEDDED" #endif #endif #ifdef DEMOPOLISH_ENABLED #include "demo_polish/demo_polish.h" #endif #include "imaterialproxydict.h" #include "tier0/miniprofiler.h" #include "../../engine/iblackbox.h" #include "c_rumble.h" #include "viewpostprocess.h" #ifdef INFESTED_PARTICLES #include "c_asw_generic_emitter.h" #endif #ifdef INFESTED_DLL #include "missionchooser/iasw_mission_chooser.h" #endif #include "tier1/UtlDict.h" #include "keybindinglistener.h" // 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; IFileLoggingListener *filelogginglistener = NULL; IGameUIFuncs *gameuifuncs = NULL; IGameEventManager2 *gameeventmanager = NULL; ISoundEmitterSystemBase *soundemitterbase = NULL; IInputSystem *inputsystem = NULL; ISceneFileCache *scenefilecache = NULL; IXboxSystem *xboxsystem = NULL; // Xbox 360 only IAvi *avi = NULL; IBik *bik = NULL; IUploadGameStats *gamestatsuploader = NULL; IBlackBox *blackboxrecorder = NULL; #ifdef INFESTED_DLL IASW_Mission_Chooser *missionchooser = NULL; #endif #if defined( REPLAY_ENABLED ) IReplayHistoryManager *g_pReplayHistoryManager = NULL; #endif IScriptManager *scriptmanager = NULL; IGameSystem *SoundEmitterSystem(); IGameSystem *ToolFrameworkClientSystem(); IViewRender *GetViewRenderInstance(); static CSteamAPIContext g_SteamAPIContext; CSteamAPIContext *steamapicontext = &g_SteamAPIContext; bool g_bEngineIsHLTV = false; static bool g_bRequestCacheUsedMaterials = false; void RequestCacheUsedMaterials() { g_bRequestCacheUsedMaterials = true; } void ProcessCacheUsedMaterials() { if ( !g_bRequestCacheUsedMaterials ) return; g_bRequestCacheUsedMaterials = false; if ( materials ) { materials->CacheUsedMaterials(); } } static bool g_bHeadTrackingEnabled = false; bool IsHeadTrackingEnabled() { #if defined( HL2_CLIENT_DLL ) return g_bHeadTrackingEnabled; #else return false; #endif } void VGui_ClearVideoPanels(); // String tables INetworkStringTable *g_pStringTableParticleEffectNames = NULL; INetworkStringTable *g_pStringTableExtraParticleFiles = NULL; INetworkStringTable *g_StringTableEffectDispatch = NULL; INetworkStringTable *g_StringTableVguiScreen = NULL; INetworkStringTable *g_pStringTableMaterials = NULL; INetworkStringTable *g_pStringTableInfoPanel = NULL; INetworkStringTable *g_pStringTableClientSideChoreoScenes = NULL; 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; 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() {} 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 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"); // Physics system bool g_bLevelInitialized; bool g_bTextMode = false; static ConVar *g_pcv_ThreadMode = NULL; // implements ACTIVE_SPLITSCREEN_PLAYER_GUARD (cdll_client_int.h) CSetActiveSplitScreenPlayerGuard::CSetActiveSplitScreenPlayerGuard( char const *pchContext, int nLine, int slot, int nOldSlot, bool bSetVguiScreenSize ) : CVGuiScreenSizeSplitScreenPlayerGuard( bSetVguiScreenSize, slot, nOldSlot ) { if ( nOldSlot == slot && engine->IsLocalPlayerResolvable() ) { m_bChanged = false; return; } m_bChanged = true; m_pchContext = pchContext; m_nLine = nLine; m_nSaveSlot = engine->SetActiveSplitScreenPlayerSlot( slot >= 0 ? slot : 0 ); m_bSaveGetLocalPlayerAllowed = engine->SetLocalPlayerIsResolvable( pchContext, nLine, slot >= 0 ); } CSetActiveSplitScreenPlayerGuard::CSetActiveSplitScreenPlayerGuard( char const *pchContext, int nLine, C_BaseEntity *pEntity, int nOldSlot, bool bSetVguiScreenSize ) : CVGuiScreenSizeSplitScreenPlayerGuard( bSetVguiScreenSize, pEntity, nOldSlot ) { int slot = C_BasePlayer::GetSplitScreenSlotForPlayer( pEntity ); if ( slot == -1 ) { m_bChanged = false; return; } if ( nOldSlot == slot && engine->IsLocalPlayerResolvable()) { m_bChanged = false; return; } m_bChanged = true; m_pchContext = pchContext; m_nLine = nLine; m_nSaveSlot = engine->SetActiveSplitScreenPlayerSlot( slot >= 0 ? slot : 0 ); m_bSaveGetLocalPlayerAllowed = engine->SetLocalPlayerIsResolvable( pchContext, nLine, slot >= 0 ); } CSetActiveSplitScreenPlayerGuard::~CSetActiveSplitScreenPlayerGuard() { if ( !m_bChanged ) return; engine->SetActiveSplitScreenPlayerSlot( m_nSaveSlot ); engine->SetLocalPlayerIsResolvable( m_pchContext, m_nLine, m_bSaveGetLocalPlayerAllowed ); } static CUtlRBTree< const char *, int > g_Hacks( 0, 0, DefLessFunc( char const * ) ); CON_COMMAND( cl_dumpsplithacks, "Dump split screen workarounds." ) { for ( int i = g_Hacks.FirstInorder(); i != g_Hacks.InvalidIndex(); i = g_Hacks.NextInorder( i ) ) { Msg( "%s\n", g_Hacks[ i ] ); } } CHackForGetLocalPlayerAccessAllowedGuard::CHackForGetLocalPlayerAccessAllowedGuard( char const *pszContext, bool bOldState ) { if ( bOldState ) { m_bChanged = false; return; } m_bChanged = true; m_pszContext = pszContext; if ( g_Hacks.Find( pszContext ) == g_Hacks.InvalidIndex() ) { g_Hacks.Insert( pszContext ); } m_bSaveGetLocalPlayerAllowed = engine->SetLocalPlayerIsResolvable( pszContext, 0, true ); } CHackForGetLocalPlayerAccessAllowedGuard::~CHackForGetLocalPlayerAccessAllowedGuard() { if ( !m_bChanged ) return; engine->SetLocalPlayerIsResolvable( m_pszContext, 0, m_bSaveGetLocalPlayerAllowed ); } CVGuiScreenSizeSplitScreenPlayerGuard::CVGuiScreenSizeSplitScreenPlayerGuard( bool bActive, int slot, int nOldSlot ) { if ( !bActive ) { m_bNoRestore = true; return; } if ( vgui::surface()->IsScreenSizeOverrideActive() && nOldSlot == slot && engine->IsLocalPlayerResolvable() ) { m_bNoRestore = true; return; } m_bNoRestore = false; vgui::surface()->GetScreenSize( m_nOldSize[ 0 ], m_nOldSize[ 1 ] ); int x, y, w, h; VGui_GetHudBounds( slot >= 0 ? slot : 0, x, y, w, h ); m_bOldSetting = vgui::surface()->ForceScreenSizeOverride( true, w, h ); } CVGuiScreenSizeSplitScreenPlayerGuard::CVGuiScreenSizeSplitScreenPlayerGuard( bool bActive, C_BaseEntity *pEntity, int nOldSlot ) { if ( !bActive ) { m_bNoRestore = true; return; } int slot = C_BasePlayer::GetSplitScreenSlotForPlayer( pEntity ); if ( vgui::surface()->IsScreenSizeOverrideActive() && nOldSlot == slot && engine->IsLocalPlayerResolvable() ) { m_bNoRestore = true; return; } m_bNoRestore = false; vgui::surface()->GetScreenSize( m_nOldSize[ 0 ], m_nOldSize[ 1 ] ); // Get size for this user int x, y, w, h; VGui_GetHudBounds( slot >= 0 ? slot : 0, x, y, w, h ); m_bOldSetting = vgui::surface()->ForceScreenSizeOverride( true, w, h ); } CVGuiScreenSizeSplitScreenPlayerGuard::~CVGuiScreenSizeSplitScreenPlayerGuard() { if ( m_bNoRestore ) return; vgui::surface()->ForceScreenSizeOverride( m_bOldSetting, m_nOldSize[ 0 ], m_nOldSize[ 1 ] ); } CVGuiAbsPosSplitScreenPlayerGuard::CVGuiAbsPosSplitScreenPlayerGuard( int slot, int nOldSlot, bool bInvert /*=false*/ ) { if ( nOldSlot == slot && engine->IsLocalPlayerResolvable() && vgui::surface()->IsScreenPosOverrideActive() ) { m_bNoRestore = true; return; } m_bNoRestore = false; // Get size for this user int x, y, w, h; VGui_GetHudBounds( slot, x, y, w, h ); if ( bInvert ) { x = -x; y = -y; } vgui::surface()->ForceScreenPosOffset( true, x, y ); } CVGuiAbsPosSplitScreenPlayerGuard::~CVGuiAbsPosSplitScreenPlayerGuard() { if ( m_bNoRestore ) return; vgui::surface()->ForceScreenPosOffset( false, 0, 0 ); } //----------------------------------------------------------------------------- // 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 ); } } // if true, the gameui applies the blur effect bool ClientWantsBlurEffect( void ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( 0 ); if ( GetViewPortInterface()->GetActivePanel() && GetViewPortInterface()->GetActivePanel()->WantsBackgroundBlurred() ) return true; return false; } }; EXPOSE_SINGLE_INTERFACE( CGameClientExports, IGameClientExports, GAMECLIENTEXPORTS_INTERFACE_VERSION ); class CClientDLLSharedAppSystems : public IClientDLLSharedAppSystems { public: CClientDLLSharedAppSystems() { AddAppSystem( "soundemittersystem", SOUNDEMITTERSYSTEM_INTERFACE_VERSION ); AddAppSystem( "scenefilecache", SCENE_FILE_CACHE_INTERFACE_VERSION ); #ifdef GAMEUI_UISYSTEM2_ENABLED AddAppSystem( "client", GAMEUISYSTEMMGR_INTERFACE_VERSION ); #endif #ifdef INFESTED_DLL AddAppSystem( "missionchooser", ASW_MISSION_CHOOSER_VERSION ); #endif } 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 g_BoneSetupEnts( BoneSetupCompare ); void TrackBoneSetupEnt( C_BaseAnimating *pEnt ) { #ifdef _DEBUG 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 ( !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 Connect( CreateInterfaceFn appSystemFactory, CGlobalVarsBase *pGlobals ); virtual int Init( CreateInterfaceFn appSystemFactory, CGlobalVarsBase *pGlobals ); virtual void PostInit(); virtual void Shutdown( void ); 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 ); // 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( int nSlot, bf_write *buf, int from, int to, bool isnewcommand ); virtual void EncodeUserCmdToBuffer( int nSlot, bf_write& buf, int slot ); virtual void DecodeUserCmdFromBuffer( int nSlot, 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, int iSsSlot, 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 void RecordDemoPolishUserInput( int nCmdIndex ); // Cache replay ragdolls virtual bool CacheReplayRagdolls( const char* pFilename, int nStartTick ); // save game screenshot writing virtual void WriteSaveGameScreenshotOfSize( const char *pFilename, int width, int height ); // Gets the location of the player viewpoint virtual bool GetPlayerView( CViewSetup &playerView ); virtual bool ShouldHideLoadingPlaque( void ); virtual void InvalidateMdlCache(); virtual void OnActiveSplitscreenPlayerChanged( int nNewSlot ); virtual void OnSplitScreenStateChanged(); virtual void CenterStringOff(); virtual void OnScreenSizeChanged( int nOldWidth, int nOldHeight ); virtual IMaterialProxy *InstantiateMaterialProxy( const char *proxyName ); virtual vgui::VPANEL GetFullscreenClientDLLVPanel( void ); virtual void MarkEntitiesAsTouching( IClientEntity *e1, IClientEntity *e2 ); virtual void OnKeyBindingChanged( ButtonCode_t buttonCode, char const *pchKeyName, char const *pchNewBinding ); virtual bool HandleGameUIEvent( const InputEvent_t &event ); public: void PrecacheMaterial( const char *pMaterialName ); virtual void SetBlurFade( float scale ); virtual void ResetHudCloseCaption(); virtual bool SupportsRandomMaps(); private: void UncacheAllMaterials( ); void ResetStringTablePointers(); CUtlRBTree< IMaterial * > m_CachedMaterials; CHudCloseCaption *m_pHudCloseCaption; }; 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 //----------------------------------------------------------------------------- int PrecacheParticleSystem( const char *pParticleSystemName ) { int nIndex = g_pStringTableParticleEffectNames->AddString( false, pParticleSystemName ); g_pParticleSystemMgr->PrecacheParticleSystem( nIndex, pParticleSystemName ); return nIndex; } //----------------------------------------------------------------------------- // 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"; } //----------------------------------------------------------------------------- // Precache-related methods for effects //----------------------------------------------------------------------------- void PrecacheEffect( const char *pEffectName ) { // Bring in dependent resources g_pPrecacheSystem->Cache( g_pPrecacheHandler, DISPATCH_EFFECT, pEffectName, true, RESOURCE_LIST_INVALID, true ); } //----------------------------------------------------------------------------- // 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; m_pHudCloseCaption = NULL; SetDefLessFunc( m_CachedMaterials ); } extern IGameSystem *ViewportClientSystem(); // enable threaded init functions on x360 static ConVar cl_threaded_init("cl_threaded_init", IsX360() ? "1" : "0"); bool InitParticleManager() { if (!ParticleMgr()->Init(MAX_TOTAL_PARTICLES, materials)) return false; return true; } bool InitGameSystems( CreateInterfaceFn appSystemFactory ) { 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( g_pPrecacheRegister ); IGameSystem::Add( SoundEmitterSystem() ); IGameSystem::Add( ToolFrameworkClientSystem() ); IGameSystem::Add( ClientLeafSystem() ); IGameSystem::Add( DetailObjectSystem() ); IGameSystem::Add( ViewportClientSystem() ); IGameSystem::Add( g_pClientShadowMgr ); IGameSystem::Add( g_pColorCorrectionMgr ); #ifdef GAMEUI_UISYSTEM2_ENABLED IGameSystem::Add( g_pGameUIGameSystem ); #endif IGameSystem::Add( ClientThinkList() ); IGameSystem::Add( ClientSoundscapeSystem() ); IGameSystem::Add( PerfVisualBenchmark() ); #if defined( CLIENT_DLL ) && defined( COPY_CHECK_STRESSTEST ) IGameSystem::Add( GetPredictionCopyTester() ); #endif ActivityList_Init(); ActivityList_RegisterSharedActivities(); EventList_Init(); EventList_RegisterSharedEvents(); modemanager->Init( ); // Load the ClientScheme just once vgui::scheme()->LoadSchemeFromFileEx( VGui_GetFullscreenRootVPANEL(), "resource/ClientScheme.res", "ClientScheme"); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetClientMode()->InitViewport(); if ( hh == 0 ) { GetFullscreenClientMode()->InitViewport(); } } for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetHud().Init(); } for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetClientMode()->Init(); if ( hh == 0 ) { GetFullscreenClientMode()->Init(); } } if ( !IGameSystem::InitAllSystems() ) return false; for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetClientMode()->Enable(); if ( hh == 0 ) { GetFullscreenClientMode()->EnableWithRootPanel( VGui_GetFullscreenRootVPANEL() ); } } // Each mod is required to implement this view = GetViewRenderInstance(); if ( !view ) { Error( "GetViewRenderInstance() must be implemented by game." ); } view->Init(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetViewEffects()->Init(); } C_BaseTempEntity::PrecacheTempEnts(); input->Init_All(); VGui_CreateGlobalPanels(); InitSmokeFogOverlay(); // Register user messages.. for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); 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( appSystemFactory ) ) return false; g_pGameSaveRestoreBlockSet->AddBlockHandler( GetEntitySaveRestoreBlockHandler() ); g_pGameSaveRestoreBlockSet->AddBlockHandler( GetPhysSaveRestoreBlockHandler() ); g_pGameSaveRestoreBlockSet->AddBlockHandler( GetViewEffectsRestoreBlockHandler() ); ClientWorldFactoryInit(); return true; } //----------------------------------------------------------------------------- // Purpose: Called when the DLL is first loaded. // Input : engineFactory - // Output : int //----------------------------------------------------------------------------- int CHLClient::Connect( CreateInterfaceFn appSystemFactory, CGlobalVarsBase *pGlobals ) { InitCRTMemDebug(); MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f ); // Hook up global variables gpGlobals = pGlobals; ConnectTier1Libraries( &appSystemFactory, 1 ); ConnectTier2Libraries( &appSystemFactory, 1 ); ConnectTier3Libraries( &appSystemFactory, 1 ); #ifndef _X360 SteamAPI_InitSafe(); g_SteamAPIContext.Init(); #ifdef INFESTED_DLL #endif #endif // Initialize the console variables. ConVar_Register( FCVAR_CLIENTDLL ); return true; } int CHLClient::Init( CreateInterfaceFn appSystemFactory, CGlobalVarsBase *pGlobals ) { COM_TimestampedLog( "ClientDLL factories - Start" ); // 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 ( (filelogginglistener = (IFileLoggingListener *)appSystemFactory(FILELOGGINGLISTENER_INTERFACE_VERSION, 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 ( IsPC() && !IsPosix() && (avi = (IAvi *)appSystemFactory(AVI_INTERFACE_VERSION, NULL)) == NULL ) return false; #if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 ) if ( (bik = (IBik *)appSystemFactory(BIK_INTERFACE_VERSION, NULL)) == NULL ) return false; #endif if ( (scenefilecache = (ISceneFileCache *)appSystemFactory( SCENE_FILE_CACHE_INTERFACE_VERSION, NULL )) == NULL ) return false; if ( (blackboxrecorder = (IBlackBox *)appSystemFactory(BLACKBOX_INTERFACE_VERSION, NULL)) == NULL ) return false; if ( (xboxsystem = (IXboxSystem *)appSystemFactory( XBOXSYSTEM_INTERFACE_VERSION, NULL )) == NULL ) return false; #if defined( REPLAY_ENABLED ) if ( IsPC() && (g_pReplayHistoryManager = (IReplayHistoryManager *)appSystemFactory( REPLAYHISTORYMANAGER_INTERFACE_VERSION, NULL )) == NULL ) return false; #endif #ifndef _XBOX if ( ( gamestatsuploader = (IUploadGameStats *)appSystemFactory( INTERFACEVERSION_UPLOADGAMESTATS, NULL )) == NULL ) return false; #endif if (!g_pMatSystemSurface) return false; #ifdef INFESTED_DLL if ( (missionchooser = (IASW_Mission_Chooser *)appSystemFactory(ASW_MISSION_CHOOSER_VERSION, NULL)) == NULL ) return false; #endif if ( !CommandLine()->CheckParm( "-noscripting") ) { scriptmanager = (IScriptManager *)appSystemFactory( VSCRIPT_INTERFACE_VERSION, NULL ); } factorylist_t factories; factories.appSystemFactory = appSystemFactory; FactoryList_Store( factories ); COM_TimestampedLog( "soundemitterbase->Connect" ); // 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; if ( CommandLine()->FindParm( "-headtracking" ) ) g_bHeadTrackingEnabled = 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 ); g_pcv_ThreadMode = g_pCVar->FindVar( "host_thread_mode" ); COM_TimestampedLog( "InitGameSystems" ); bool bInitSuccess = false; if ( cl_threaded_init.GetBool() ) { CFunctorJob *pGameJob = new CFunctorJob( CreateFunctor( InitParticleManager ) ); g_pThreadPool->AddJob( pGameJob ); bInitSuccess = InitGameSystems( appSystemFactory ); pGameJob->WaitForFinishAndRelease(); } else { COM_TimestampedLog( "ParticleMgr()->Init" ); if (!ParticleMgr()->Init(MAX_TOTAL_PARTICLES, materials)) return false; COM_TimestampedLog( "InitGameSystems - Start" ); bInitSuccess = InitGameSystems( appSystemFactory ); COM_TimestampedLog( "InitGameSystems - End" ); } #ifdef INFESTED_PARTICLES // let the emitter cache load in our standard g_ASWGenericEmitterCache.PrecacheTemplates(); #endif COM_TimestampedLog( "C_BaseAnimating::InitBoneSetupThreadPool" ); C_BaseAnimating::InitBoneSetupThreadPool(); // This is a fullscreen element, so only lives on slot 0!!! m_pHudCloseCaption = GET_FULLSCREEN_HUDELEMENT( CHudCloseCaption ); COM_TimestampedLog( "ClientDLL Init - Finish" ); return true; } //----------------------------------------------------------------------------- // Purpose: Called after client & server DLL are loaded and all systems initialized //----------------------------------------------------------------------------- void CHLClient::PostInit() { COM_TimestampedLog( "IGameSystem::PostInitAllSystems - Start" ); IGameSystem::PostInitAllSystems(); COM_TimestampedLog( "IGameSystem::PostInitAllSystems - Finish" ); } //----------------------------------------------------------------------------- // Purpose: Called when the client .dll is being dismissed //----------------------------------------------------------------------------- void CHLClient::Shutdown( void ) { ActivityList_Free(); EventList_Free(); VGui_ClearVideoPanels(); C_BaseAnimating::ShutdownBoneSetupThreadPool(); ClientWorldFactoryShutdown(); g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetViewEffectsRestoreBlockHandler() ); g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetPhysSaveRestoreBlockHandler() ); g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetEntitySaveRestoreBlockHandler() ); ClientVoiceMgr_Shutdown(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetClientMode()->Disable(); if ( hh == 0 ) { GetFullscreenClientMode()->Disable(); } } for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetClientMode()->Shutdown(); if ( hh == 0 ) { GetFullscreenClientMode()->Shutdown(); } } input->Shutdown_All(); C_BaseTempEntity::ClearDynamicTempEnts(); TermSmokeFogOverlay(); view->Shutdown(); g_pParticleSystemMgr->UncacheAllParticleSystems(); UncacheAllMaterials(); IGameSystem::ShutdownAllSystems(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); GetHud().Shutdown(); } VGui_Shutdown(); ClearKeyValuesCache(); #ifndef NO_STEAM g_SteamAPIContext.Clear(); // SteamAPI_Shutdown(); << Steam shutdown is controlled by engine #ifdef INFESTED_DLL #endif #endif DisconnectTier3Libraries( ); DisconnectTier2Libraries( ); ConVar_Unregister(); DisconnectTier1Libraries( ); } //----------------------------------------------------------------------------- // 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 ) { for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetHud().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 ) { GetClientMode()->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; GetClientVoiceMgr()->Frame( frametime ); ASSERT_LOCAL_PLAYER_NOT_RESOLVABLE(); FOR_EACH_VALID_SPLITSCREEN_PLAYER( hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetHud().UpdateHud( bActive ); } ASSERT_LOCAL_PLAYER_NOT_RESOLVABLE(); { C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false ); IGameSystem::UpdateAllSystems( frametime ); } // run vgui animations vgui::GetAnimationController()->UpdateAnimations( Plat_FloatTime() ); 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(); } //----------------------------------------------------------------------------- // Purpose: Called to restore to "non"HUD state. //----------------------------------------------------------------------------- void CHLClient::HudReset( void ) { for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetHud().VidInit(); } PhysicsReset(); } //----------------------------------------------------------------------------- // Purpose: Called to add hud text message //----------------------------------------------------------------------------- void CHLClient::HudText( const char * message ) { for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); DispatchHudText( message ); } } //----------------------------------------------------------------------------- // Handler for input events for the new game ui system //----------------------------------------------------------------------------- bool CHLClient::HandleGameUIEvent( const InputEvent_t &inputEvent ) { #ifdef GAMEUI_UISYSTEM2_ENABLED // TODO: when embedded UI will be used for HUD, we will need it to maintain // a separate screen for HUD and a separate screen stack for pause menu & main menu. // for now only render embedded UI in pause menu & main menu BaseModUI::CBaseModPanel *pBaseModPanel = BaseModUI::CBaseModPanel::GetSingletonPtr(); if ( !pBaseModPanel || !pBaseModPanel->IsVisible() ) return false; return g_pGameUIGameSystem->RegisterInputEvent( inputEvent ); #else return false; #endif } //----------------------------------------------------------------------------- // 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(); } extern ConVar in_forceuser; //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHLClient::IN_Accumulate ( void ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( in_forceuser.GetInt() ); input->AccumulateMouse( GET_ACTIVE_SPLITSCREEN_SLOT() ); } //----------------------------------------------------------------------------- // 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->GetPerUser().state & 1 ) ? true : false; // Found the key by name return true; } //----------------------------------------------------------------------------- // 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 ) { bool bSave = C_BaseEntity::IsAbsRecomputationsEnabled(); C_BaseEntity::EnableAbsRecomputations( true ); ABS_QUERY_GUARD( true ); C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false ); MDLCACHE_CRITICAL_SECTION(); input->ExtraMouseSample( frametime, active ); C_BaseEntity::EnableAbsRecomputations( bSave ); } void CHLClient::IN_SetSampleTime( float frametime ) { input->Joystick_SetSampleTime( frametime ); input->IN_SetSampleTime( frametime ); } //----------------------------------------------------------------------------- // 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( int nSlot, bf_write *buf, int from, int to, bool isnewcommand ) { return input->WriteUsercmdDeltaToBuffer( nSlot, buf, from, to, isnewcommand ); } //----------------------------------------------------------------------------- // Purpose: // Input : buf - // buffersize - //----------------------------------------------------------------------------- void CHLClient::EncodeUserCmdToBuffer( int nSlot, bf_write& buf, int slot ) { input->EncodeUserCmdToBuffer( nSlot, buf, slot ); } //----------------------------------------------------------------------------- // Purpose: // Input : buf - // buffersize - // slot - //----------------------------------------------------------------------------- void CHLClient::DecodeUserCmdFromBuffer( int nSlot, bf_read& buf, int slot ) { input->DecodeUserCmdFromBuffer( nSlot, 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; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CHLClient::InvalidateMdlCache() { C_BaseAnimating *pAnimating; for ( C_BaseEntity *pEntity = ClientEntityList().FirstBaseEntity(); pEntity; pEntity = ClientEntityList().NextBaseEntity(pEntity) ) { pAnimating = pEntity->GetBaseAnimating(); if ( pAnimating ) { pAnimating->InvalidateMdlCache(); } } CStudioHdr::CActivityToSequenceMapping::ResetMappings(); } //----------------------------------------------------------------------------- // Purpose: // Input : *pSF - //----------------------------------------------------------------------------- void CHLClient::View_Fade( ScreenFade_t *pSF ) { if ( pSF != NULL ) { FOR_EACH_VALID_SPLITSCREEN_PLAYER( hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetViewEffects()->Fade( *pSF ); } } } // CPU level //----------------------------------------------------------------------------- void ConfigureCurrentSystemLevel( ); void OnCPULevelChanged( IConVar *var, const char *pOldValue, float flOldValue ) { ConfigureCurrentSystemLevel(); } static ConVar cpu_level( "cpu_level", "2", 0, "CPU Level - Default: High", OnCPULevelChanged ); CPULevel_t GetCPULevel() { if ( IsX360() ) return CPU_LEVEL_360; return GetActualCPULevel(); } CPULevel_t GetActualCPULevel() { // Should we cache system_level off during level init? CPULevel_t nSystemLevel = (CPULevel_t)clamp( cpu_level.GetInt(), 0, CPU_LEVEL_PC_COUNT-1 ); return nSystemLevel; } //----------------------------------------------------------------------------- // GPU level //----------------------------------------------------------------------------- void OnGPULevelChanged( IConVar *var, const char *pOldValue, float flOldValue ) { ConfigureCurrentSystemLevel(); } static ConVar gpu_level( "gpu_level", "3", 0, "GPU Level - Default: High", OnGPULevelChanged ); GPULevel_t GetGPULevel() { if ( IsX360() ) return GPU_LEVEL_360; // Should we cache system_level off during level init? GPULevel_t nSystemLevel = (GPULevel_t)clamp( gpu_level.GetInt(), 0, GPU_LEVEL_PC_COUNT-1 ); return nSystemLevel; } //----------------------------------------------------------------------------- // System Memory level //----------------------------------------------------------------------------- void OnMemLevelChanged( IConVar *var, const char *pOldValue, float flOldValue ) { ConfigureCurrentSystemLevel(); } static ConVar mem_level( "mem_level", "2", 0, "Memory Level - Default: High", OnMemLevelChanged ); MemLevel_t GetMemLevel() { if ( IsX360() ) return MEM_LEVEL_360; // Should we cache system_level off during level init? MemLevel_t nSystemLevel = (MemLevel_t)clamp( mem_level.GetInt(), 0, MEM_LEVEL_PC_COUNT-1 ); return nSystemLevel; } //----------------------------------------------------------------------------- // GPU Memory level //----------------------------------------------------------------------------- void OnGPUMemLevelChanged( IConVar *var, const char *pOldValue, float flOldValue ) { ConfigureCurrentSystemLevel(); } static ConVar gpu_mem_level( "gpu_mem_level", "2", 0, "Memory Level - Default: High", OnGPUMemLevelChanged ); GPUMemLevel_t GetGPUMemLevel() { if ( IsX360() ) return GPU_MEM_LEVEL_360; // Should we cache system_level off during level init? GPUMemLevel_t nSystemLevel = (GPUMemLevel_t)clamp( gpu_mem_level.GetInt(), 0, GPU_MEM_LEVEL_PC_COUNT-1 ); return nSystemLevel; } void ConfigureCurrentSystemLevel() { int nCPULevel = GetCPULevel(); if ( nCPULevel == CPU_LEVEL_360 ) { nCPULevel = 360; } int nGPULevel = GetGPULevel(); if ( nGPULevel == GPU_LEVEL_360 ) { nGPULevel = 360; } int nMemLevel = GetMemLevel(); if ( nMemLevel == MEM_LEVEL_360 ) { nMemLevel = 360; } int nGPUMemLevel = GetGPUMemLevel(); if ( nGPUMemLevel == GPU_MEM_LEVEL_360 ) { nGPUMemLevel = 360; } #if defined( SWARM_DLL ) char szModName[32] = "swarm"; #elif defined ( HL2_EPISODIC ) char szModName[32] = "ep2"; #elif defined ( SDK_CLIENT_DLL ) char szModName[32] = "sdk"; #endif UpdateSystemLevel( nCPULevel, nGPULevel, nMemLevel, nGPUMemLevel, VGui_IsSplitScreen(), szModName ); if ( engine ) { engine->ConfigureSystemLevel( nCPULevel, nGPULevel ); } C_BaseEntity::UpdateVisibilityAllEntities(); if ( view ) { view->InitFadeData(); } } //----------------------------------------------------------------------------- // 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; engine->TickProgressBar(); input->LevelInit(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetViewEffects()->LevelInit(); } // Tell mode manager that map is changing modemanager->LevelInit( pMapName ); ParticleMgr()->LevelInit(); ClientVoiceMgr_LevelInit(); hudlcd->SetGlobalStat( "(mapname)", pMapName ); C_BaseTempEntity::ClearDynamicTempEnts(); clienteffects->Flush(); view->LevelInit(); tempents->LevelInit(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); ResetToneMapping(1.0); } IGameSystem::LevelInitPreEntityAllSystems(pMapName); 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 ); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); engine->TickProgressBar(); GetHud().LevelInit(); } #if defined( REPLAY_ENABLED ) // Initialize replay ragdoll recorder if ( !engine->IsPlayingDemo() ) { CReplayRagdollRecorder::Instance().Init(); } #endif } //----------------------------------------------------------------------------- // Purpose: Per level init //----------------------------------------------------------------------------- void CHLClient::LevelInitPostEntity( ) { ABS_QUERY_GUARD( true ); IGameSystem::LevelInitPostEntityAllSystems(); C_PhysPropClientside::RecreateAll(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetCenterPrint()->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; } //----------------------------------------------------------------------------- // Purpose: Per level de-init //----------------------------------------------------------------------------- void CHLClient::LevelShutdown( void ) { // HACK: Bogus, but the logic is too complicated in the engine if (!g_bLevelInitialized) { ResetStringTablePointers(); 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(); for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { StopAllRumbleEffects( hh ); } for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetHud().LevelShutdown(); } for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetCenterPrint()->Clear(); } ClientVoiceMgr_LevelShutdown(); messagechars->Clear(); g_pParticleSystemMgr->LevelShutdown(); g_pParticleSystemMgr->UncacheAllParticleSystems(); UncacheAllMaterials(); #ifdef _XBOX ReleaseRenderTargets(); #endif // string tables are cleared on disconnect from a server, so reset our global pointers to NULL ResetStringTablePointers(); CStudioHdr::CActivityToSequenceMapping::ResetMappings(); #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 ) { #ifndef INFESTED_DLL CHudCrosshair *crosshair = GET_HUDELEMENT( CHudCrosshair ); if ( crosshair ) { crosshair->SetCrosshairAngle( angle ); } #endif } //----------------------------------------------------------------------------- // 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, int iSsSlot, qboolean bTalking ) { GetClientVoiceMgr()->UpdateSpeakerStatus( entindex, iSsSlot, !!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 dispatch effects changes //----------------------------------------------------------------------------- void OnEffectStringTableChanged( void *object, INetworkStringTable *stringTable, int stringNumber, const char *newString, void const *newData ) { // Make sure this puppy is precached g_pPrecacheSystem->Cache( g_pPrecacheHandler, DISPATCH_EFFECT, newString, true, RESOURCE_LIST_INVALID, true ); 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( stringNumber, newString ); RequestCacheUsedMaterials(); } //----------------------------------------------------------------------------- // Called when the string table for particle files changes //----------------------------------------------------------------------------- void OnPrecacheParticleFile( void *object, INetworkStringTable *stringTable, int stringNumber, const char *newString, void const *newData ) { g_pParticleSystemMgr->ShouldLoadSheets( true ); g_pParticleSystemMgr->ReadParticleConfigFile( newString, true, false ); g_pParticleSystemMgr->DecommitTempMemory(); } //----------------------------------------------------------------------------- // 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 ); // When the material list changes, we need to know immediately g_StringTableEffectDispatch->SetStringChangedCallback( NULL, OnEffectStringTableChanged ); } else if ( !Q_strcasecmp( tableName, "InfoPanel" ) ) { g_pStringTableInfoPanel = networkstringtable->FindTable( tableName ); } else if ( !Q_strcasecmp( tableName, "Scenes" ) ) { g_pStringTableClientSideChoreoScenes = networkstringtable->FindTable( tableName ); networkstringtable->SetAllowClientSideAddString( g_pStringTableClientSideChoreoScenes, true ); 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, "ExtraParticleFilesTable" ) ) { g_pStringTableExtraParticleFiles = networkstringtable->FindTable( tableName ); networkstringtable->SetAllowClientSideAddString( g_pStringTableExtraParticleFiles, true ); // When the particle system list changes, we need to know immediately g_pStringTableExtraParticleFiles->SetStringChangedCallback( NULL, OnPrecacheParticleFile ); } else { // Pass tablename to gamerules last if all other checks fail InstallStringTableCallback_GameRules( tableName ); } } //----------------------------------------------------------------------------- // 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 ) ) { int idx = m_CachedMaterials.Find( pMaterial ); if ( idx == m_CachedMaterials.InvalidIndex() ) { pMaterial->IncrementReferenceCount(); m_CachedMaterials.Insert( pMaterial ); } } } void CHLClient::UncacheAllMaterials( ) { for ( int i = m_CachedMaterials.FirstInorder(); i != m_CachedMaterials.InvalidIndex(); i = m_CachedMaterials.NextInorder( i ) ) { 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(); C_BaseEntity::SimulateEntities(); } bool AddDataChangeEvent( IClientNetworkable *ent, DataUpdateType_t updateType, int *pStoredEvent ) { 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); int nSave = GET_ACTIVE_SPLITSCREEN_SLOT(); bool bSaveAccess = engine->SetLocalPlayerIsResolvable( __FILE__, __LINE__, false ); 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(); engine->SetActiveSplitScreenPlayerSlot( nSave ); engine->SetLocalPlayerIsResolvable( __FILE__, __LINE__, bSaveAccess ); } 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 &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 &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(); 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_BaseFlex::InvalidateFlexCaches(); 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. for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); input->CAM_Think(); } C_BaseAnimating::PopBoneAccess( "OnRenderStart->CViewRender::SetUpView" ); // pops the (true, false) bone access set in OnRenderStart // Enable access to all model bones until rendering is done C_BaseAnimating::PushAllowBoneAccess( true, true, "CViewRender::SetUpView->OnRenderEnd" ); // pop is in OnRenderEnd() #ifdef DEMOPOLISH_ENABLED // Update demo polish subsystem if necessary DemoPolish_Think(); #endif // This will place all entities in the correct position in world space and in the KD-tree // NOTE: Doing this before view->OnRenderStart() because the player can be in hierarchy with // a client-side animated entity. So the viewport position is dependent on this animation sometimes. C_BaseAnimating::UpdateClientSideAnimations(); // 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(); 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. C_BaseAnimating::ThreadedBoneSetup(); // Simulate all the entities. SimulateEntities(); PhysicsSimulate(); { 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). { 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 // update dynamic light state. Necessary for light cache to work properly for d- and elights engine->UpdateDAndELights(); // Finally, link all the entities into the leaf system right before rendering. C_BaseEntity::AddVisibleEntities(); g_pClientLeafSystem->RecomputeRenderableLeaves(); g_pClientShadowMgr->ReprojectShadows(); g_pClientShadowMgr->AdvanceFrame(); g_pClientLeafSystem->DisableLeafReinsertion( true ); } void OnRenderEnd() { g_pClientLeafSystem->DisableLeafReinsertion( false ); // 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; g_bEngineIsHLTV = engine->IsHLTV(); switch( curStage ) { default: break; case FRAME_RENDER_START: { VPROF( "CHLClient::FrameStageNotify FRAME_RENDER_START" ); engine->SetLocalPlayerIsResolvable( __FILE__, __LINE__, false ); // Last thing before rendering, run simulation. OnRenderStart(); } break; case FRAME_RENDER_END: { VPROF( "CHLClient::FrameStageNotify FRAME_RENDER_END" ); OnRenderEnd(); engine->SetLocalPlayerIsResolvable( __FILE__, __LINE__, false ); 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(); engine->SetLocalPlayerIsResolvable( __FILE__, __LINE__, false ); } 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 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 ) { // Single player doesn't support split screen yet!!! ACTIVE_SPLITSCREEN_PLAYER_GUARD( 0 ); 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; if ( m_pHudCloseCaption ) { m_pHudCloseCaption->ProcessSentenceCaptionStream( tokenstream ); } } void CHLClient::EmitCloseCaption( char const *captionname, float duration ) { extern ConVar closecaption; if ( !closecaption.GetBool() ) return; if ( m_pHudCloseCaption ) { m_pHudCloseCaption->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 ) { #ifdef DEMOPOLISH_ENABLED if ( IsDemoPolishEnabled() ) { if ( !CDemoPolishRecorder::Instance().Init( pDemoBaseName ) ) { CDemoPolishRecorder::Instance().Shutdown(); } } #endif } void CHLClient::OnDemoRecordStop() { #ifdef DEMOPOLISH_ENABLED if ( DemoPolish_GetRecorder().m_bInit ) { DemoPolish_GetRecorder().Shutdown(); } #endif } void CHLClient::OnDemoPlaybackStart( char const* pDemoBaseName ) { #ifdef DEMOPOLISH_ENABLED if ( IsDemoPolishEnabled() ) { Assert( pDemoBaseName ); if ( !DemoPolish_GetController().Init( pDemoBaseName ) ) { DemoPolish_GetController().Shutdown(); } } #endif #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 } void CHLClient::RecordDemoPolishUserInput( int nCmdIndex ) { #ifdef DEMOPOLISH_ENABLED ASSERT_LOCAL_PLAYER_RESOLVABLE(); int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT(); Assert( engine->IsRecordingDemo() ); Assert( IsDemoPolishEnabled() ); // NOTE: cl_demo_polish_enabled checked in engine. CUserCmd const* pUserCmd = input->GetUserCmd( nSlot, nCmdIndex ); Assert( pUserCmd ); if ( pUserCmd ) { DemoPolish_GetRecorder().RecordUserInput( pUserCmd ); } #endif } bool CHLClient::CacheReplayRagdolls( const char* pFilename, int nStartTick ) { #if defined( REPLAY_ENABLED ) return Replay_CacheRagdolls( pFilename, nStartTick ); #else return false; #endif } // NEW INTERFACES // save game screenshot writing void CHLClient::WriteSaveGameScreenshotOfSize( const char *pFilename, int width, int height ) { view->WriteSaveGameScreenshotOfSize( pFilename, width, height ); } // See RenderViewInfo_t void CHLClient::RenderView( const CViewSetup &setup, int nClearFlags, int whatToDraw ) { VPROF("RenderView"); view->RenderView( setup, setup, nClearFlags, whatToDraw ); } bool CHLClient::ShouldHideLoadingPlaque( void ) { return false; } void CHLClient::OnActiveSplitscreenPlayerChanged( int nNewSlot ) { } void CHLClient::OnSplitScreenStateChanged() { VGui_OnSplitScreenStateChanged(); IterateRemoteSplitScreenViewSlots_Push( true ); FOR_EACH_VALID_SPLITSCREEN_PLAYER( i ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( i ); GetClientMode()->Layout(); GetHud().OnSplitScreenStateChanged(); } IterateRemoteSplitScreenViewSlots_Pop(); GetFullscreenClientMode()->Layout( true ); vgui::surface()->ResetFontCaches(); // Update visibility for all ents so that the second viewport for the split player guy looks right, etc. C_BaseEntityIterator iterator; C_BaseEntity *pEnt; while ( (pEnt = iterator.Next()) != NULL ) { pEnt->UpdateVisibility(); } } void CHLClient::CenterStringOff() { FOR_EACH_VALID_SPLITSCREEN_PLAYER( i ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( i ); GetCenterPrint()->Clear(); } } void CHLClient::OnScreenSizeChanged( int nOldWidth, int nOldHeight ) { // Tell split screen system VGui_OnScreenSizeChanged(); } IMaterialProxy *CHLClient::InstantiateMaterialProxy( const char *proxyName ) { #ifdef GAMEUI_UISYSTEM2_ENABLED IMaterialProxy *pProxy = g_pGameUIGameSystem->CreateProxy( proxyName ); if ( pProxy ) return pProxy; #endif return GetMaterialProxyDict().CreateProxy( proxyName ); } vgui::VPANEL CHLClient::GetFullscreenClientDLLVPanel( void ) { return VGui_GetFullscreenRootVPANEL(); } int XBX_GetActiveUserId() { ASSERT_LOCAL_PLAYER_RESOLVABLE(); return XBX_GetUserId( GET_ACTIVE_SPLITSCREEN_SLOT() ); } //----------------------------------------------------------------------------- // Purpose: Marks entities as touching // Input : *e1 - // *e2 - //----------------------------------------------------------------------------- void CHLClient::MarkEntitiesAsTouching( IClientEntity *e1, IClientEntity *e2 ) { CBaseEntity *entity = e1->GetBaseEntity(); CBaseEntity *entityTouched = e2->GetBaseEntity(); if ( entity && entityTouched ) { trace_t tr; UTIL_ClearTrace( tr ); tr.endpos = (entity->GetAbsOrigin() + entityTouched->GetAbsOrigin()) * 0.5; entity->PhysicsMarkEntitiesAsTouching( entityTouched, tr ); } } class CKeyBindingListenerMgr : public IKeyBindingListenerMgr { public: struct BindingListeners_t { BindingListeners_t() { } BindingListeners_t( const BindingListeners_t &other ) { m_List.CopyArray( other.m_List.Base(), other.m_List.Count() ); } CUtlVector< IKeyBindingListener * > m_List; }; // Callback when button is bound virtual void AddListenerForCode( IKeyBindingListener *pListener, ButtonCode_t buttonCode ) { CUtlVector< IKeyBindingListener * > &list = m_CodeListeners[ buttonCode ]; if ( list.Find( pListener ) != list.InvalidIndex() ) return; list.AddToTail( pListener ); } // Callback whenver binding is set to a button virtual void AddListenerForBinding( IKeyBindingListener *pListener, char const *pchBindingString ) { int idx = m_BindingListeners.Find( pchBindingString ); if ( idx == m_BindingListeners.InvalidIndex() ) { idx = m_BindingListeners.Insert( pchBindingString ); } CUtlVector< IKeyBindingListener * > &list = m_BindingListeners[ idx ].m_List; if ( list.Find( pListener ) != list.InvalidIndex() ) return; list.AddToTail( pListener ); } virtual void RemoveListener( IKeyBindingListener *pListener ) { for ( int i = 0; i < ARRAYSIZE( m_CodeListeners ); ++i ) { CUtlVector< IKeyBindingListener * > &list = m_CodeListeners[ i ]; list.FindAndRemove( pListener ); } for ( int i = m_BindingListeners.First(); i != m_BindingListeners.InvalidIndex(); i = m_BindingListeners.Next( i ) ) { CUtlVector< IKeyBindingListener * > &list = m_BindingListeners[ i ].m_List; list.FindAndRemove( pListener ); } } void OnKeyBindingChanged( ButtonCode_t buttonCode, char const *pchKeyName, char const *pchNewBinding ) { int nSplitScreenSlot = GET_ACTIVE_SPLITSCREEN_SLOT(); CUtlVector< IKeyBindingListener * > &list = m_CodeListeners[ buttonCode ]; for ( int i = 0 ; i < list.Count(); ++i ) { list[ i ]->OnKeyBindingChanged( nSplitScreenSlot, buttonCode, pchKeyName, pchNewBinding ); } int idx = m_BindingListeners.Find( pchNewBinding ); if ( idx != m_BindingListeners.InvalidIndex() ) { CUtlVector< IKeyBindingListener * > &list = m_BindingListeners[ idx ].m_List; for ( int i = 0 ; i < list.Count(); ++i ) { list[ i ]->OnKeyBindingChanged( nSplitScreenSlot, buttonCode, pchKeyName, pchNewBinding ); } } } private: CUtlVector< IKeyBindingListener * > m_CodeListeners[ BUTTON_CODE_COUNT ]; CUtlDict< BindingListeners_t, int > m_BindingListeners; }; static CKeyBindingListenerMgr g_KeyBindingListenerMgr; IKeyBindingListenerMgr *g_pKeyBindingListenerMgr = &g_KeyBindingListenerMgr; void CHLClient::OnKeyBindingChanged( ButtonCode_t buttonCode, char const *pchKeyName, char const *pchNewBinding ) { g_KeyBindingListenerMgr.OnKeyBindingChanged( buttonCode, pchKeyName, pchNewBinding ); } void CHLClient::SetBlurFade( float scale ) { FOR_EACH_VALID_SPLITSCREEN_PLAYER( hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh ); GetClientMode()->SetBlurFade( scale ); } } void CHLClient::ResetHudCloseCaption() { if ( !IsX360() ) { // only xbox needs to force the close caption system to remount return; } if ( m_pHudCloseCaption ) { // force the caption dictionary to remount m_pHudCloseCaption->InitCaptionDictionary( NULL, true ); } } bool CHLClient::SupportsRandomMaps() { #ifdef INFESTED_DLL return true; #else return false; #endif } extern IViewRender *view; //----------------------------------------------------------------------------- // Purpose: interface from materialsystem to client, currently just for recording into tools //----------------------------------------------------------------------------- class CClientMaterialSystem : public IClientMaterialSystem { virtual HTOOLHANDLE GetCurrentRecordingEntity() { if ( !ToolsEnabled() ) return HTOOLHANDLE_INVALID; if ( !clienttools->IsInRecordingMode() ) return HTOOLHANDLE_INVALID; C_BaseEntity *pEnt = view->GetCurrentlyDrawingEntity(); if ( !pEnt || !pEnt->IsToolRecording() ) return HTOOLHANDLE_INVALID; return pEnt->GetToolHandle(); } virtual void PostToolMessage( HTOOLHANDLE hEntity, KeyValues *pMsg ) { ToolFramework_PostToolMessage( hEntity, pMsg ); } }; //----------------------------------------------------------------------------- // Singleton instance //----------------------------------------------------------------------------- static CClientMaterialSystem s_ClientMaterialSystem; IClientMaterialSystem *g_pClientMaterialSystem = &s_ClientMaterialSystem; EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CClientMaterialSystem, IClientMaterialSystem, VCLIENTMATERIALSYSTEM_INTERFACE_VERSION, s_ClientMaterialSystem );