d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
67 Commits
25 Branches
6 Tags
221 MiB
Tree: c1c616e569
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c1c616e569'
${ noResults }
source-engine/engine/host.cpp

5026 lines
130 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "tier0/fasttimer.h"
#ifdef _WIN32
#include "tier0/memdbgon.h" // needed because in release builds crtdbg.h is handled specially if USE_MEM_DEBUG is defined
#include "tier0/memdbgoff.h"
#include <crtdbg.h> // For getting at current heap size
#endif
#include "tier1/fmtstr.h"
#include "vstdlib/jobthread.h"
#ifdef USE_SDL
#include "appframework/ilaunchermgr.h"
extern ILauncherMgr *g_pLauncherMgr;
#endif
#include "server.h"
#include "host_jmp.h"
#include "screen.h"
#include "keys.h"
#include "cdll_int.h"
#include "eiface.h"
#include "sv_main.h"
#include "sv_log.h"
#include "shadowmgr.h"
#include "zone.h"
#include "gl_cvars.h"
#include "sv_filter.h"
#include "ivideomode.h"
#include "vprof_engine.h"
#include "iengine.h"
#include "tier2/tier2.h"
#include "enginethreads.h"
#include "steam/steam_api.h"
#include "LoadScreenUpdate.h"
#include "datacache/idatacache.h"
#if !defined SWDS
#include "voice.h"
#include "sound.h"
#endif
#include "icvar.h"
#include "sys.h"
#include "client.h"
#include "cl_pred.h"
#include "console.h"
#include "view.h"
#include "host.h"
#include "decal.h"
#include "gl_matsysiface.h"
#include "gl_shader.h"
#include "sys_dll.h"
#include "cmodel_engine.h"
#ifndef SWDS
#include "con_nprint.h"
#endif
#include "filesystem.h"
#include "filesystem_engine.h"
#include "tier0/etwprof.h"
#include "tier0/vcrmode.h"
#include "traceinit.h"
#include "host_saverestore.h"
#include "l_studio.h"
#include "cl_demo.h"
#include "cdll_engine_int.h"
#include "host_cmd.h"
#include "host_state.h"
#include "dt_instrumentation.h"
#include "dt_instrumentation_server.h"
#include "const.h"
#include "bitbuf_errorhandler.h"
#include "soundflags.h"
#include "enginestats.h"
#include "tier1/strtools.h"
#include "testscriptmgr.h"
#include "tmessage.h"
#include "tier0/vprof.h"
#include "tier0/icommandline.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "MapReslistGenerator.h"
#include "DownloadListGenerator.h"
#include "download.h"
#include "staticpropmgr.h"
#include "GameEventManager.h"
#include "iprediction.h"
#include "netmessages.h"
#include "cl_main.h"
#include "hltvserver.h"
#include "hltvtest.h"
#if defined( REPLAY_ENABLED )
#include "replayserver.h"
#include "replay_internal.h"
#endif
#include "sys_mainwind.h"
#include "host_phonehome.h"
#ifndef SWDS
#include "vgui_baseui_interface.h"
#include "cl_steamauth.h"
#endif
#include "sv_remoteaccess.h" // NotifyDedicatedServerUI()
#include "snd_audio_source.h"
#include "sv_steamauth.h"
#include "MapReslistGenerator.h"
#include "DevShotGenerator.h"
#include "sv_plugin.h"
#include "toolframework/itoolframework.h"
#include "ienginetoolinternal.h"
#include "inputsystem/iinputsystem.h"
#include "vgui_askconnectpanel.h"
#include "cvar.h"
#include "saverestoretypes.h"
#include "filesystem/IQueuedLoader.h"
#include "soundservice.h"
#include "profile.h"
#include "steam/isteamremotestorage.h"
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#include "audio_pch.h"
#endif
#if defined( LINUX )
#include <locale.h>
#include "SDL.h"
#endif
#include "ixboxsystem.h"
extern IXboxSystem *g_pXboxSystem;
extern ConVar cl_cloud_settings;
extern ConVar cl_logofile;
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
void CL_SetPagedPoolInfo();
extern char *CM_EntityString( void );
extern ConVar host_map;
extern ConVar sv_cheats;
bool g_bDedicatedServerBenchmarkMode = false;
bool g_bAllowSecureServers = true;
bool g_bLowViolence = false;
// These counters are for debugging in dumps. If these are non-zero it may indicate some kind of
// heap problem caused by the setjmp/longjmp error handling
int g_HostServerAbortCount = 0;
int g_HostErrorCount = 0;
int g_HostEndDemo = 0;
char g_szDefaultLogoFileName[] = "materials/vgui/logos/spray.vtf";
int host_frameticks = 0;
int host_tickcount = 0;
int host_currentframetick = 0;
static const char g_pModuleExtension[] = DLL_EXT_STRING;
// 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()
//------------------------------------------
enum
{
FRAME_SEGMENT_INPUT = 0,
FRAME_SEGMENT_CLIENT,
FRAME_SEGMENT_SERVER,
FRAME_SEGMENT_RENDER,
FRAME_SEGMENT_SOUND,
FRAME_SEGMENT_CLDLL,
FRAME_SEGMENT_CMD_EXECUTE,
NUM_FRAME_SEGMENTS,
};
class CFrameTimer
{
public:
void ResetDeltas();
CFrameTimer() : swaptime(0)
{
ResetDeltas();
}
void MarkFrame();
void StartFrameSegment( int i )
{
starttime[i] = Sys_FloatTime();
}
void EndFrameSegment( int i )
{
double dt = Sys_FloatTime() - starttime[i];
deltas[ i ] += dt;
}
void MarkSwapTime( )
{
double newswaptime = Sys_FloatTime();
frametime = newswaptime - swaptime;
swaptime = newswaptime;
ComputeFrameVariability();
g_EngineStats.SetFrameTime( frametime );
g_EngineStats.SetFPSVariability( m_flFPSVariability );
host_frametime_stddeviation = m_flFPSStdDeviationSeconds;
}
private:
enum
{
FRAME_HISTORY_COUNT = 50
};
friend void Host_Speeds();
void ComputeFrameVariability();
double time_base;
double times[9];
double swaptime;
double frametime;
double m_flFPSVariability;
double m_flFPSStdDeviationSeconds;
double starttime[NUM_FRAME_SEGMENTS];
double deltas[NUM_FRAME_SEGMENTS];
float m_pFrameTimeHistory[FRAME_HISTORY_COUNT];
int m_nFrameTimeHistoryIndex;
};
static CFrameTimer g_HostTimes;
//------------------------------------------
float host_time = 0.0;
static ConVar violence_hblood( "violence_hblood","1", 0, "Draw human blood" );
static ConVar violence_hgibs( "violence_hgibs","1", 0, "Show human gib entities" );
static ConVar violence_ablood( "violence_ablood","1", 0, "Draw alien blood" );
static ConVar violence_agibs( "violence_agibs","1", 0, "Show alien gib entities" );
// Marked as FCVAR_USERINFO so that the server can cull CC messages before networking them down to us!!!
ConVar closecaption( "closecaption", "0", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX | FCVAR_USERINFO, "Enable close captioning." );
extern ConVar sv_unlockedchapters;
void Snd_Restart_f()
{
#ifndef SWDS
extern bool snd_firsttime;
char szVoiceCodec[_MAX_PATH] = { 0 };
int nVoiceSampleRate = Voice_ConfiguredSampleRate();
{
// This is not valid after voice shuts down
const char *pPreviousCodec = Voice_ConfiguredCodec();
if ( pPreviousCodec && *pPreviousCodec )
{
V_strncpy( szVoiceCodec, pPreviousCodec, sizeof( szVoiceCodec ) );
}
}
S_Shutdown();
snd_firsttime = true;
cl.ClearSounds();
S_Init();
// Restart voice if it was running
if ( szVoiceCodec[0] )
Voice_Init( szVoiceCodec, nVoiceSampleRate );
// Do this or else it won't have anything in the cache.
if ( audiosourcecache && sv.GetMapName()[0] )
{
audiosourcecache->LevelInit( sv.GetMapName() );
}
// Flush soundscapes so they don't stop. We don't insert text in the buffer here because
// cl_soundscape_flush is normally cheat-protected.
ConCommand *pCommand = (ConCommand*)dynamic_cast< const ConCommand* >( g_pCVar->FindCommand( "cl_soundscape_flush" ) );
if ( pCommand )
{
char const *argv[ 1 ] = { "cl_soundscape_flush" };
CCommand cmd( 1, argv );
pCommand->Dispatch( cmd );
}
#endif
}
static ConCommand snd_restart( "snd_restart", Snd_Restart_f, "Restart sound system." );
// In other C files.
void Shader_Shutdown( void );
void R_Shutdown( void );
bool g_bAbortServerSet = false;
#ifdef _WIN32
static bool s_bInitPME = false;
#endif
CON_COMMAND( mem_dump, "Dump memory stats to text file." )
{
ConMsg("Writing memory stats to file memstats.txt\n");
#if defined( _MEMTEST )
const char *pTest = sv.GetMapName();
if ( !pTest || !pTest[0] )
{
// possibly at menu
pTest = "unknown";
}
MemAlloc_SetStatsExtraInfo( pTest,"" );
#endif
MemAlloc_DumpStats();
}
CON_COMMAND( mem_compact, "" )
{
MemAlloc_CompactHeap();
}
CON_COMMAND( mem_eat, "" )
{
MemAlloc_Alloc( 1024* 1024 );
}
CON_COMMAND( mem_test, "" )
{
MemAlloc_CrtCheckMemory();
}
static ConVar host_competitive_ever_enabled( "host_competitive_ever_enabled", "0", FCVAR_HIDDEN, "Has competitive ever been enabled this run?", true, 0, true, 1, true, 1, false, 1, NULL );
static ConVar mem_test_each_frame( "mem_test_each_frame", "0", 0, "Run heap check at end of every frame\n" );
static ConVar mem_test_every_n_seconds( "mem_test_every_n_seconds", "0", 0, "Run heap check at a specified interval\n" );
static ConVar singlestep( "singlestep", "0", FCVAR_CHEAT, "Run engine in single step mode ( set next to 1 to advance a frame )" );
static ConVar cvarNext( "next", "0", FCVAR_CHEAT, "Set to 1 to advance to next frame ( when singlestep == 1 )" );
// Print a debug message when the client or server cache is missed
ConVar host_showcachemiss( "host_showcachemiss", "0", 0, "Print a debug message when the client or server cache is missed." );
static ConVar mem_dumpstats( "mem_dumpstats", "0", 0, "Dump current and max heap usage info to console at end of frame ( set to 2 for continuous output )\n" );
static ConVar host_ShowIPCCallCount( "host_ShowIPCCallCount", "0", 0, "Print # of IPC calls this number of times per second. If set to -1, the # of IPC calls is shown every frame." );
#if defined( RAD_TELEMETRY_ENABLED )
static void OnChangeTelemetryPause ( IConVar *var, const char *pOldValue, float flOldValue )
{
tmPause( TELEMETRY_LEVEL0, 1 );
}
static void OnChangeTelemetryResume ( IConVar *var, const char *pOldValue, float flOldValue )
{
tmPause( TELEMETRY_LEVEL0, 0 );
}
static void OnChangeTelemetryLevel ( IConVar *var, const char *pOldValue, float flOldValue )
{
char* pIEnd;
const char *pLevel = (( ConVar* )var)->GetString();
TelemetrySetLevel( strtoul( pLevel, &pIEnd, 0 ) );
}
static void OnChangeTelemetryFrameCount ( IConVar *var, const char *pOldValue, float flOldValue )
{
char* pIEnd;
const char *pFrameCount = (( ConVar* )var)->GetString();
g_Telemetry.FrameCount = strtoul( pFrameCount, &pIEnd, 0 );
Msg( " TELEMETRY: Setting Telemetry FrameCount: '%d'\n", g_Telemetry.FrameCount );
}
static void OnChangeTelemetryServer ( IConVar *var, const char *pOldValue, float flOldValue )
{
const char *pServerAddress = (( ConVar* )var)->GetString();
Q_strncpy( g_Telemetry.ServerAddress, pServerAddress, ARRAYSIZE( g_Telemetry.ServerAddress ) );
Msg( " TELEMETRY: Setting Telemetry server: '%s'\n", pServerAddress );
}
static void OnChangeTelemetryDemoStart ( IConVar *var, const char *pOldValue, float flOldValue )
{
char* pIEnd;
const char *pVal = (( ConVar* )var)->GetString();
g_Telemetry.DemoTickStart = strtoul( pVal, &pIEnd, 0 );
if( g_Telemetry.DemoTickStart > 2000 )
{
char cmd[ 256 ];
// If we're far away from the start of the demo file, then jump to ~1000 ticks before.
Q_snprintf( cmd, sizeof( cmd ), "demo_gototick %d", g_Telemetry.DemoTickStart - 1000 );
Cbuf_AddText( cmd );
}
Msg( " TELEMETRY: Setting Telemetry DemoTickStart: '%d'\n", g_Telemetry.DemoTickStart );
}
static void OnChangeTelemetryDemoEnd ( IConVar *var, const char *pOldValue, float flOldValue )
{
char* pIEnd;
const char *pVal = (( ConVar* )var)->GetString();
g_Telemetry.DemoTickEnd = strtoul( pVal, &pIEnd, 0 );
Msg( " TELEMETRY: Setting Telemetry DemoTickEnd: '%d'\n", g_Telemetry.DemoTickEnd );
}
ConVar telemetry_pause( "telemetry_pause", "0", 0, "Pause Telemetry", OnChangeTelemetryPause );
ConVar telemetry_resume( "telemetry_resume", "0", 0, "Resume Telemetry", OnChangeTelemetryResume );
ConVar telemetry_framecount( "telemetry_framecount", "0", 0, "Set Telemetry count of frames to capture", OnChangeTelemetryFrameCount );
ConVar telemetry_level( "telemetry_level", "0", 0, "Set Telemetry profile level: 0 being off.", OnChangeTelemetryLevel );
ConVar telemetry_server( "telemetry_server", "localhost", 0, "Set Telemetry server", OnChangeTelemetryServer );
ConVar telemetry_demostart( "telemetry_demostart", "0", 0, "When playing demo, start telemetry on tick #", OnChangeTelemetryDemoStart );
ConVar telemetry_demoend( "telemetry_demoend", "0", 0, "When playing demo, stop telemetry on tick #", OnChangeTelemetryDemoEnd );
#endif
extern bool gfBackground;
static bool host_checkheap = false;
CCommonHostState host_state;
//-----------------------------------------------------------------------------
enum HostThreadMode
{
HTM_DISABLED,
HTM_DEFAULT,
HTM_FORCED,
};
ConVar host_thread_mode( "host_thread_mode", ( IsX360() ) ? "1" : "0", 0, "Run the host in threaded mode, (0 == off, 1 == if multicore, 2 == force)" );
extern ConVar threadpool_affinity;
void OnChangeThreadAffinity( IConVar *var, const char *pOldValue, float flOldValue )
{
if ( g_pThreadPool->NumThreads() )
{
g_pThreadPool->Distribute( threadpool_affinity.GetBool() );
}
}
ConVar threadpool_affinity( "threadpool_affinity", "1", 0, "Enable setting affinity", 0, 0, 0, 0, &OnChangeThreadAffinity );
#if 0
extern ConVar threadpool_reserve;
CThreadEvent g_ReleaseThreadReservation( true );
CInterlockedInt g_NumReservedThreads;
void ThreadPoolReserverFunction()
{
g_ReleaseThreadReservation.Wait();
--g_NumReservedThreads;
}
void ReserveThreads( int nToReserve )
{
nToReserve = clamp( nToReserve, 0, g_pThreadPool->NumThreads() );
g_ReleaseThreadReservation.Set();
while ( g_NumReservedThreads != 0 )
{
ThreadSleep( 0 );
}
g_ReleaseThreadReservation.Reset();
while ( nToReserve-- )
{
g_NumReservedThreads++;
g_pThreadPool->QueueCall( &ThreadPoolReserverFunction )->Release();
}
Msg( "%d threads being reserved\n", (int)g_NumReservedThreads );
}
void OnChangeThreadReserve( IConVar *var, const char *pOldValue, float flOldValue )
{
ReserveThreads( threadpool_reserve.GetInt() );
}
ConVar threadpool_reserve( "threadpool_reserve", "0", 0, "Consume the specified number of threads in the thread pool", 0, 0, 0, 0, &OnChangeThreadReserve );
CON_COMMAND( threadpool_cycle_reserve, "Cycles threadpool reservation by powers of 2" )
{
int nCores = g_pThreadPool->NumThreads() + 1;
int nAvailableCores = nCores - g_NumReservedThreads;
Assert( nAvailableCores );
int ratio = nCores / nAvailableCores;
ratio *= 2;
if ( ratio > nCores )
{
ReserveThreads( 0 );
}
else
{
ReserveThreads( nCores - nCores / ratio );
}
}
CON_COMMAND( thread_test_tslist, "" )
{
int nTests = ( args.ArgC() == 1 ) ? 10000 : atoi( args.Arg( 1 ) );
RunTSListTests( nTests );
}
CON_COMMAND( thread_test_tsqueue, "" )
{
int nTests = ( args.ArgC() == 1 ) ? 10000 : atoi( args.Arg( 1 ) );
RunTSQueueTests( nTests );
}
CON_COMMAND( threadpool_run_tests, "" )
{
int nTests = ( args.ArgC() == 1 ) ? 1 : atoi( args.Arg( 1 ) );
for ( int i = 0; i < nTests; i++ )
{
RunThreadPoolTests();
}
}
#endif
//-----------------------------------------------------------------------------
/*
A server can always be started, even if the system started out as a client
to a remote system.
A client can NOT be started if the system started as a dedicated server.
Memory is cleared / released when a server or client begins, not when they end.
*/
// Ear position + orientation
static AudioState_t s_AudioState;
engineparms_t host_parms;
bool host_initialized = false; // true if into command execution
float host_frametime = 0.0f;
float host_frametime_unbounded = 0.0f;
float host_frametime_stddeviation = 0.0f;
double realtime = 0; // without any filtering or bounding
double host_idealtime = 0; // "ideal" server time assuming perfect tick rate
float host_nexttick = 0; // next server tick in this many ms
float host_jitterhistory[128] = { 0 };
unsigned int host_jitterhistorypos = 0;
int host_framecount;
static int host_hunklevel;
CGameClient *host_client; // current client
jmp_buf host_abortserver;
jmp_buf host_enddemo;
static ConVar host_profile( "host_profile","0" );
ConVar host_limitlocal( "host_limitlocal", "0", 0, "Apply cl_cmdrate and cl_updaterate to loopback connection" );
ConVar host_framerate( "host_framerate","0", 0, "Set to lock per-frame time elapse." );
ConVar host_timescale( "host_timescale","1.0", FCVAR_REPLICATED, "Prescale the clock by this amount." );
ConVar host_speeds( "host_speeds","0", 0, "Show general system running times." ); // set for running times
ConVar host_flush_threshold( "host_flush_threshold", "20", 0, "Memory threshold below which the host should flush caches between server instances" );
void HostTimerSpinMsChangedCallback( IConVar *var, const char *pOldString, float flOldValue );
ConVar host_timer_spin_ms( "host_timer_spin_ms", "0", FCVAR_NONE, "Use CPU busy-loop for improved timer precision (dedicated only)", HostTimerSpinMsChangedCallback );
void HostTimerSpinMsChangedCallback( IConVar *var, const char *pOldString, float flOldValue )
{
const char *pForcedValue = CommandLine()->ParmValue( "+host_timer_spin_ms" );
if ( pForcedValue != NULL )
{
if ( V_strcmp( host_timer_spin_ms.GetString(), pForcedValue ) )
{
Msg( "Value for host_timer_spin_ms is locked to %s by command line parameter.\n", pForcedValue );
host_timer_spin_ms.SetValue( pForcedValue );
}
}
}
CON_COMMAND( host_timer_report, "Spew CPU timer jitter for the last 128 frames in microseconds (dedicated only)" )
{
if ( sv.IsDedicated() )
{
for (int i = 1; i <= ARRAYSIZE( host_jitterhistory ); ++i)
{
unsigned int slot = ( i + host_jitterhistorypos ) % ARRAYSIZE( host_jitterhistory );
Msg( "%1.3fms\n", host_jitterhistory[ slot ] * 1000 );
}
}
}
#ifdef REL_TO_STAGING_MERGE_TODO
// Do this when merging the game DLLs so FCVAR_CHEAT can be set on them at the same time.
ConVar developer( "developer", "0", FCVAR_CHEAT, "Set developer message level");
#else
ConVar developer( "developer", "0", 0, "Set developer message level");
#endif
ConVar skill( "skill","1", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX, "Game skill level (1-3).", true, 1, true, 3 ); // 1 - 3
ConVar deathmatch( "deathmatch","0", FCVAR_NOTIFY | FCVAR_INTERNAL_USE, "Running a deathmatch server." ); // 0, 1, or 2
ConVar coop( "coop","0", FCVAR_NOTIFY, "Cooperative play." ); // 0 or 1
#ifdef _DEBUG
ConVar r_ForceRestore( "r_ForceRestore", "0", 0 );
#endif // _DEBUG
ConVar vcr_verbose( "vcr_verbose", "0", 0, "Write extra information into .vcr file." );
#ifndef SWDS
void CL_CheckToDisplayStartupMenus(); // in cl_main.cpp
#endif
bool GetFileFromRemoteStorage( ISteamRemoteStorage *pRemoteStorage, const char *pszRemoteFileName, const char *pszLocalFileName )
{
bool bSuccess = false;
// check if file exists in Steam Cloud first
int32 nFileSize = pRemoteStorage->GetFileSize( pszRemoteFileName );
if ( nFileSize > 0 )
{
CUtlMemory<char> buf( 0, nFileSize );
if ( pRemoteStorage->FileRead( pszRemoteFileName, buf.Base(), nFileSize ) == nFileSize )
{
char filepath[ 512 ];
Q_strncpy( filepath, pszLocalFileName, sizeof( filepath ) );
Q_StripFilename( filepath );
g_pFullFileSystem->CreateDirHierarchy( filepath, "MOD" );
FileHandle_t hFile = g_pFileSystem->Open( pszLocalFileName, "wb", "MOD" );
if( hFile )
{
bSuccess = g_pFileSystem->Write( buf.Base(), nFileSize, hFile ) == nFileSize;
g_pFileSystem->Close( hFile );
if ( bSuccess )
{
DevMsg( "[Cloud]: SUCCEESS retrieved %s from remote storage into %s\n", pszRemoteFileName, pszLocalFileName );
}
else
{
DevMsg( "[Cloud]: FAILED retrieved %s from remote storage into %s\n", pszRemoteFileName, pszLocalFileName );
}
}
}
}
return bSuccess;
}
void CCommonHostState::SetWorldModel( model_t *pModel )
{
worldmodel = pModel;
if ( pModel )
{
worldbrush = pModel->brush.pShared;
}
else
{
worldbrush = NULL;
}
}
void Host_DefaultMapFileName( const char *pFullMapName, /* out */ char *pDiskName, unsigned int nDiskNameSize )
{
if ( IsPC() || !IsX360() )
{
// pc names are as is
Q_snprintf( pDiskName, nDiskNameSize, "maps/%s.bsp", pFullMapName );
}
else if ( IsX360() )
{
Q_snprintf( pDiskName, nDiskNameSize, "maps/%s.360.bsp", pFullMapName );
}
}
void Host_SetAudioState( const AudioState_t &audioState )
{
memcpy( &s_AudioState, &audioState, sizeof(AudioState_t) );
}
bool Host_IsSinglePlayerGame( void )
{
if ( sv.IsActive() )
{
return !sv.IsMultiplayer();
}
else
{
return cl.m_nMaxClients == 1;
}
}
void CheckForFlushMemory( const char *pCurrentMapName, const char *pDestMapName )
{
if ( host_flush_threshold.GetInt() == 0 )
return;
#if defined(_X360)
// There are three cases in which we flush memory
// Case 1: changing from one map to another
// -> flush temp data caches
// Case 2: loading any map (inc. A to A) and free memory is below host_flush_threshold MB
// -> flush everything
// Case 3: loading a 'blacklisted' map (the known biggest memory users, or where texture sets change)
// -> flush everything
static const char *mapBlackList[] =
{
// --hl2--
"d1_canals_01",
"d1_canals_05",
"d1_eli_01",
"d1_town_01",
"d2_coast_01",
"d2_prison_01",
"d3_c17_01",
"d3_c17_05",
"d3_c17_09",
"d3_citadel_01",
"d3_breen_01",
// --ep1--
"ep1_c17_02",
"ep1_c17_02b",
"ep1_c17_05",
"ep1_c17_06",
// --ep2--
"ep2_outland_06a",
"ep2_outland_09",
"ep2_outland_11",
"ep2_outland_12",
"ep2_outland_12a",
// --tf--
"tc_hydro"
};
char szCurrentMapName[MAX_PATH];
char szDestMapName[MAX_PATH];
if ( pCurrentMapName )
{
V_FileBase( pCurrentMapName, szCurrentMapName, sizeof( szCurrentMapName ) );
}
else
{
szCurrentMapName[0] = '\0';
}
pCurrentMapName = szCurrentMapName;
if ( pDestMapName )
{
V_FileBase( pDestMapName, szDestMapName, sizeof( szDestMapName ) );
}
else
{
szDestMapName[0] = '\0';
}
pDestMapName = szDestMapName;
bool bIsMapChanging = pCurrentMapName[0] && V_stricmp( pCurrentMapName, pDestMapName );
bool bIsDestMapBlacklisted = false;
for ( int i = 0; i < ARRAYSIZE( mapBlackList ); i++ )
{
if ( pDestMapName && !V_stricmp( pDestMapName, mapBlackList[i] ) )
{
bIsDestMapBlacklisted = true;
}
}
DevMsg( "---CURRENT(%s), NEXT(%s)\n", (pCurrentMapName[0] ? pCurrentMapName : "----"), (pDestMapName[0] ? pDestMapName : "----") );
if ( bIsMapChanging )
{
DevMsg( "---CHANGING MAPS!\n" );
}
if ( bIsDestMapBlacklisted )
{
DevMsg( "---BLACKLISTED!\n" );
}
MEMORYSTATUS stat;
GlobalMemoryStatus( &stat );
if ( ( stat.dwAvailPhys < host_flush_threshold.GetInt() * 1024 * 1024 ) ||
( bIsDestMapBlacklisted && bIsMapChanging ) )
{
// Flush everything; ALL data is reloaded from scratch
SV_FlushMemoryOnNextServer();
g_pDataCache->Flush();
DevWarning( "---FULL FLUSH\n" );
}
else if ( bIsMapChanging )
{
// Flush temporary data (async anim, non-locked async audio)
g_pMDLCache->Flush( MDLCACHE_FLUSH_ANIMBLOCK );
wavedatacache->Flush();
DevWarning( "---PARTIAL FLUSH\n" );
}
DevMsg( "---- --- ----\n" );
#endif
}
void Host_AbortServer()
{
g_HostServerAbortCount++;
longjmp( host_abortserver, 1 );
}
/*
================
Host_EndGame
================
*/
void Host_EndGame (bool bShowMainMenu, const char *message, ...)
{
int oldn;
va_list argptr;
char string[1024];
va_start (argptr,message);
Q_vsnprintf (string,sizeof(string),message,argptr);
va_end (argptr);
ConMsg ("Host_EndGame: %s\n",string);
#ifndef SWDS
scr_disabled_for_loading = true;
#endif
oldn = cl.demonum;
cl.demonum = -1;
Host_Disconnect(bShowMainMenu);
cl.demonum = oldn;
if ( sv.IsDedicated() )
{
Sys_Error ("Host_EndGame: %s\n",string); // dedicated servers exit
return;
}
if (cl.demonum != -1)
{
#ifndef SWDS
CL_NextDemo ();
#endif
g_HostEndDemo++;
longjmp (host_enddemo, 1);
}
else
{
#ifndef SWDS
scr_disabled_for_loading = false;
#endif
if ( g_bAbortServerSet )
{
Host_AbortServer();
}
}
}
/*
================
Host_Error
This shuts down both the client and server
================
*/
void Host_Error (const char *error, ...)
{
va_list argptr;
char string[1024];
static bool inerror = false;
DebuggerBreakIfDebugging_StagingOnly();
g_HostErrorCount++;
if (inerror)
{
Sys_Error ("Host_Error: recursively entered");
}
inerror = true;
#ifndef SWDS
// CL_WriteMessageHistory(); TODO must be done by network layer
#endif
va_start (argptr,error);
Q_vsnprintf(string,sizeof(string),error,argptr);
va_end (argptr);
if ( sv.IsDedicated() )
{
// dedicated servers just exit
Sys_Error( "Host_Error: %s\n", string );
return;
}
#ifndef SWDS
// Reenable screen updates
SCR_EndLoadingPlaque ();
#endif
ConMsg( "\nHost_Error: %s\n\n", string );
Host_Disconnect( true, string );
cl.demonum = -1;
inerror = false;
if ( g_bAbortServerSet )
{
Host_AbortServer();
}
}
#ifndef SWDS
ButtonCode_t nInvalidKeyBindings[] =
{
KEY_PAD_0,
KEY_PAD_1,
KEY_PAD_2,
KEY_PAD_3,
KEY_PAD_4,
KEY_PAD_5,
KEY_PAD_6,
KEY_PAD_7,
KEY_PAD_8,
KEY_PAD_9,
KEY_PAD_DIVIDE,
KEY_PAD_MULTIPLY,
KEY_PAD_MINUS,
KEY_PAD_PLUS,
KEY_PAD_ENTER,
KEY_PAD_DECIMAL,
KEY_ESCAPE,
KEY_SCROLLLOCK,
KEY_INSERT,
KEY_DELETE,
KEY_HOME,
KEY_END,
KEY_PAGEUP,
KEY_PAGEDOWN,
KEY_BREAK,
KEY_LSHIFT,
KEY_RSHIFT,
KEY_LALT,
KEY_RALT,
KEY_LCONTROL,
KEY_RCONTROL,
KEY_LWIN,
KEY_RWIN,
KEY_APP,
KEY_UP,
KEY_LEFT,
KEY_DOWN,
KEY_RIGHT,
KEY_CAPSLOCKTOGGLE,
KEY_NUMLOCKTOGGLE,
KEY_SCROLLLOCKTOGGLE,
KEY_BACKQUOTE,
};
//******************************************
// SetupNewBindings
//
// In the rare case that we ship an update
// where we need a key to be bound to a given
// con-command, this function do its best to
// bind those keys, based on a file called
// newbindings.txt.
//******************************************
void SetupNewBindings()
{
char szBindCmd[ 256 ];
// Load the file
const char *pFilename = "scripts\\newbindings.txt";
KeyValues *pNewBindingsData = new KeyValues( pFilename );
if ( !pNewBindingsData->LoadFromFile( g_pFileSystem, pFilename ) )
{
pNewBindingsData->deleteThis();
return;
}
FOR_EACH_TRUE_SUBKEY( pNewBindingsData, pSubKey )
{
// Get the binding
const char *pBinding = pSubKey->GetName();
if ( !pBinding )
continue;
// Get the ideal key
const char *pIdealKey = pSubKey->GetString( "ideal_key", NULL );
if ( !pIdealKey )
continue;
// Force the key binding if the ideal key is bound to an irrelevant command, which is the
// case for CS:S, which binds F6 to "quick save," which has no used in the game at all.
const char *pOverrideIfCmd = pSubKey->GetString( "override_if", NULL );
if ( pOverrideIfCmd )
{
const char *pCurrentBindingForKey = ::Key_BindingForKey( g_pInputSystem->StringToButtonCode( pIdealKey ) );
if ( !pCurrentBindingForKey || !V_stricmp( pOverrideIfCmd, pCurrentBindingForKey ) )
{
V_snprintf( szBindCmd, sizeof( szBindCmd ), "bind \"%s\" \"%s\"", pIdealKey, pBinding );
Cbuf_AddText( szBindCmd );
continue;
}
}
// Already have a key for this command?
if ( ::Key_NameForBinding( pBinding ) )
continue;
// No binding. Is the ideal key available?
ButtonCode_t bcIdealKey = g_pInputSystem->StringToButtonCode( pIdealKey );
const char *pCurrentBindingForIdealKey = ::Key_BindingForKey( bcIdealKey );
if ( !pCurrentBindingForIdealKey )
{
// Yes - bind to the ideal key.
V_snprintf( szBindCmd, sizeof( szBindCmd ), "bind \"%s\" \"%s\"", pIdealKey, pBinding );
Cbuf_AddText( szBindCmd );
continue;
}
// Ideal key already bound - find another key at random and bind it
bool bFound = false;
int nNumAttempts = 1;
for ( int nCurButton = (int)KEY_0; nCurButton <= (int)KEY_LAST; ++nCurButton, ++nNumAttempts )
{
// Don't consider numpad, windows keys, etc
bool bFoundInvalidKey = false;
for ( int iKeyIndex = 0; iKeyIndex < sizeof( nInvalidKeyBindings )/sizeof( nInvalidKeyBindings[0] ); iKeyIndex++ )
{
if ( nCurButton == (int)nInvalidKeyBindings[iKeyIndex] )
{
bFoundInvalidKey = true;
break;
}
}
if ( bFoundInvalidKey )
continue;
// Key available?
ButtonCode_t bcCurButton = (ButtonCode_t)nCurButton;
if ( !::Key_BindingForKey( bcCurButton ) )
{
// Yes - use it.
V_snprintf( szBindCmd, sizeof( szBindCmd ), "bind \"%s\" \"%s\"", g_pInputSystem->ButtonCodeToString( bcCurButton ), pBinding );
Cbuf_AddText( szBindCmd );
bFound = true;
break;
}
}
// We tried really hard - did we fail?
if ( !bFound )
{
Warning( "Unable to bind a key for command \"%s\" after %i attempt(s).\n", pBinding, nNumAttempts );
}
}
}
//******************************************
// UseDefuaultBinding
//
// If the config.cfg file is not present, this
// function is called to set the default key
// bindings to match those defined in kb_def.lst
//******************************************
void UseDefaultBindings( void )
{
FileHandle_t f;
char szFileName[ _MAX_PATH ];
char token[ 1024 ];
char szKeyName[ 256 ];
// read kb_def file to get default key binds
Q_snprintf( szFileName, sizeof( szFileName ), "%skb_def.lst", SCRIPT_DIR );
f = g_pFileSystem->Open( szFileName, "r");
if ( !f )
{
ConMsg( "Couldn't open kb_def.lst\n" );
return;
}
// read file into memory
int size = g_pFileSystem->Size(f);
char *startbuf = new char[ size ];
g_pFileSystem->Read( startbuf, size, f );
g_pFileSystem->Close( f );
const char *buf = startbuf;
while ( 1 )
{
buf = COM_ParseFile( buf, token, sizeof( token ) );
if ( strlen( token ) <= 0 )
break;
Q_strncpy ( szKeyName, token, sizeof( szKeyName ) );
buf = COM_ParseFile( buf, token, sizeof( token ) );
if ( strlen( token ) <= 0 ) // Error
break;
// finally, bind key
Key_SetBinding ( g_pInputSystem->StringToButtonCode( szKeyName ), token );
}
delete [] startbuf; // cleanup on the way out
}
static bool g_bConfigCfgExecuted = false;
//-----------------------------------------------------------------------------
// Purpose: Write out our 360 exclusive settings to internal storage
//-----------------------------------------------------------------------------
void Host_WriteConfiguration_360( void )
{
#ifdef _X360
if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )
return;
// Construct the name for our config settings for this mod
char strFilename[MAX_PATH];
Q_snprintf( strFilename, sizeof(strFilename), "cfg:/%s_config.cfg", GetCurrentMod() );
// Always throw away all keys that are left over.
CUtlBuffer configBuff( 0, 0, CUtlBuffer::TEXT_BUFFER);
configBuff.Printf( "unbindall\n" );
Key_WriteBindings( configBuff );
cv->WriteVariables( configBuff );
ConVarRef mat_monitorgamma( "mat_monitorgamma" );
ConVarRef mat_monitorgamma_tv_enabled( "mat_monitorgamma_tv_enabled" );
char strVideoFilename[MAX_PATH];
CUtlBuffer videoBuff( 0, 0, CUtlBuffer::TEXT_BUFFER);
Q_snprintf( strVideoFilename, sizeof(strVideoFilename), "cfg:/video_config.cfg" );
videoBuff.Printf( "mat_monitorgamma %f\n", mat_monitorgamma.GetFloat() );
videoBuff.Printf( "mat_monitorgamma_tv_enabled %d\n", mat_monitorgamma_tv_enabled.GetBool() );
// Anything to write?
if ( configBuff.TellMaxPut() )
{
g_pFileSystem->WriteFile( strFilename, NULL, configBuff );
}
if ( videoBuff.TellMaxPut() )
{
g_pFileSystem->WriteFile( strVideoFilename, NULL, videoBuff );
}
g_pXboxSystem->FinishContainerWrites();
#endif // #ifdef _X360
}
/*
===============
Host_WriteConfiguration
Writes key bindings and archived cvars to config.cfg
===============
*/
void Host_WriteConfiguration( const char *filename, bool bAllVars )
{
const bool cbIsUserRequested = ( filename != NULL );
if ( !filename )
filename = "config.cfg";
if ( !g_bConfigCfgExecuted )
return;
if ( !host_initialized )
return;
// Don't write config when in default--most of the values are defaults which is not what the player wants.
// If bAllVars is set, go ahead and write out the file anyways, since it was requested explicitly.
if ( !cbIsUserRequested && ( CommandLine()->CheckParm( "-default" ) || host_competitive_ever_enabled.GetBool() ) )
return;
// Write to internal storage on the 360
if ( IsX360() )
{
Host_WriteConfiguration_360();
return;
}
// If in map editing mode don't save configuration
if (g_bInEditMode)
{
ConMsg( "skipping %s output when in map edit mode\n", filename );
return;
}
// dedicated servers initialize the host but don't parse and set the
// config.cfg cvars
if ( sv.IsDedicated() )
return;
if ( IsPC() && Key_CountBindings() <= 1 )
{
ConMsg( "skipping %s output, no keys bound\n", filename );
return;
}
// force any queued convar changes to flush before reading/writing them
UpdateMaterialSystemConfig();
// Generate a new .cfg file.
char szFileName[MAX_PATH];
CUtlBuffer configBuff( 0, 0, CUtlBuffer::TEXT_BUFFER);
Q_snprintf( szFileName, sizeof(szFileName), "cfg/%s", filename );
g_pFileSystem->CreateDirHierarchy( "cfg", "MOD" );
if ( g_pFileSystem->FileExists( szFileName, "MOD" ) && !g_pFileSystem->IsFileWritable( szFileName, "MOD" ) )
{
ConMsg( "Config file %s is read-only!!\n", szFileName );
return;
}
// Always throw away all keys that are left over.
configBuff.Printf( "unbindall\n" );
Key_WriteBindings( configBuff );
cv->WriteVariables( configBuff, bAllVars );
#if !defined( SWDS )
bool down;
if ( g_ClientDLL->IN_IsKeyDown( "in_jlook", down ) && down )
{
configBuff.Printf( "+jlook\n" );
}
#endif // SWDS
if ( !configBuff.TellMaxPut() )
{
// nothing to write
return;
}
#if defined(NO_STEAM)
AssertMsg( false, "SteamCloud not available on Xbox 360. Badger Martin to fix this." );
#else
ISteamRemoteStorage *pRemoteStorage = SteamClient()?(ISteamRemoteStorage *)SteamClient()->GetISteamGenericInterface(
SteamAPI_GetHSteamUser(), SteamAPI_GetHSteamPipe(), STEAMREMOTESTORAGE_INTERFACE_VERSION ):NULL;
if ( pRemoteStorage )
{
int32 availableBytes, totalBytes = 0;
if ( pRemoteStorage->GetQuota( &totalBytes, &availableBytes ) )
{
if ( totalBytes > 0 )
{
if ( cl_cloud_settings.GetInt() == STEAMREMOTESTORAGE_CLOUD_ON )
{
// TODO put MOD dir in pathname
if ( pRemoteStorage->FileWrite( szFileName, configBuff.Base(), configBuff.TellMaxPut() ) )
{
DevMsg( "[Cloud]: SUCCEESS saving %s in remote storage\n", szFileName );
}
else
{
// probably a quota issue. TODO what to do ?
DevMsg( "[Cloud]: FAILED saving %s in remote storage\n", szFileName );
}
// write the current logo file
char szLogoFileName[MAX_PATH];
Q_strncpy( szLogoFileName, cl_logofile.GetString(), sizeof(szLogoFileName) ); // .vtf file
if ( g_pFileSystem->FileExists( szLogoFileName, "MOD" ) )
{
// store logo .VTF file
FileHandle_t hFile = g_pFileSystem->Open( szLogoFileName, "rb", "MOD" );
if ( FILESYSTEM_INVALID_HANDLE != hFile )
{
unsigned int unSize = g_pFileSystem->Size( hFile );
byte *pBuffer = (byte*) malloc( unSize );
if ( g_pFileSystem->Read( pBuffer, unSize, hFile ) == unSize )
{
Q_SetExtension( g_szDefaultLogoFileName, ".vtf", sizeof(g_szDefaultLogoFileName) );
if ( pRemoteStorage->FileWrite( g_szDefaultLogoFileName, pBuffer, unSize ) )
{
DevMsg( "[Cloud]: SUCCEESS saving %s in remote storage\n", g_szDefaultLogoFileName );
}
else
{
DevMsg( "[Cloud]: FAILED saving %s in remote storage\n", g_szDefaultLogoFileName );
}
}
free( pBuffer );
g_pFileSystem->Close( hFile );
}
// store logo .VMT file
Q_SetExtension( szLogoFileName, ".vmt", sizeof(szLogoFileName) );
hFile = g_pFileSystem->Open( szLogoFileName, "rb", "MOD" );
if ( FILESYSTEM_INVALID_HANDLE != hFile )
{
unsigned int unSize = g_pFileSystem->Size( hFile );
byte *pBuffer = (byte*) malloc( unSize );
if ( g_pFileSystem->Read( pBuffer, unSize, hFile ) == unSize )
{
Q_SetExtension( g_szDefaultLogoFileName, ".vmt", sizeof(g_szDefaultLogoFileName) );
if ( pRemoteStorage->FileWrite( g_szDefaultLogoFileName, pBuffer, unSize ) )
{
DevMsg( "[Cloud]: SUCCEESS saving %s in remote storage\n", g_szDefaultLogoFileName );
}
else
{
DevMsg( "[Cloud]: FAILED saving %s in remote storage\n", g_szDefaultLogoFileName );
}
}
free( pBuffer );
g_pFileSystem->Close( hFile );
}
}
}
}
}
// even if SteamCloud worked we still safe the same file locally
}
#endif
// make a persistent copy that async will use and free
char *tempBlock = new char[configBuff.TellMaxPut()];
Q_memcpy( tempBlock, configBuff.Base(), configBuff.TellMaxPut() );
// async write the buffer, and then free it
g_pFileSystem->AsyncWrite( szFileName, tempBlock, configBuff.TellMaxPut(), true );
ConMsg( "Host_WriteConfiguration: Wrote %s\n", szFileName );
}
//-----------------------------------------------------------------------------
// Purpose: Retrieve and set any defaults from the user's gamer profile
//-----------------------------------------------------------------------------
bool XBX_SetProfileDefaultSettings( void )
{
// These defined values can't play nicely with the PC, so we need to ignore them for that build target
#ifdef _X360
// These will act as indices into the array that is returned by the API
enum
{
XPS_GAMER_DIFFICULTY,
XPS_GAMER_ACTION_MOVEMENT_CONTROL,
XPS_GAMER_YAXIS_INVERSION,
XPS_OPTION_CONTROLLER_VIBRATION,
NUM_PROFILE_SETTINGS
};
// These are the values we're interested in having returned (must match the indices above)
const DWORD dwSettingIds[ NUM_PROFILE_SETTINGS ] =
{
XPROFILE_GAMER_DIFFICULTY,
XPROFILE_GAMER_ACTION_MOVEMENT_CONTROL,
XPROFILE_GAMER_YAXIS_INVERSION,
XPROFILE_OPTION_CONTROLLER_VIBRATION
};
// Must have a valid primary user by this point
int nPrimaryID = XBX_GetPrimaryUserId();
// First, we call with a NULL pointer and zero size to retrieve the buffer size we'll get back
DWORD dwResultSize = 0; // Must be zero to get the correct size back
XUSER_READ_PROFILE_SETTING_RESULT *pResults = NULL;
DWORD dwError = XUserReadProfileSettings( 0, // Family ID (current title)
nPrimaryID, // User ID
NUM_PROFILE_SETTINGS,
dwSettingIds,
&dwResultSize,
pResults,
NULL );
// We need this to inform us that it's given us a size back for the buffer
if ( dwError != ERROR_INSUFFICIENT_BUFFER )
return false;
// Now we allocate that buffer and supply it to the call
BYTE *pData = (BYTE *) stackalloc( dwResultSize );
ZeroMemory( pData, dwResultSize );
pResults = (XUSER_READ_PROFILE_SETTING_RESULT *) pData;
dwError = XUserReadProfileSettings( 0, // Family ID (current title)
nPrimaryID, // User ID
NUM_PROFILE_SETTINGS,
dwSettingIds,
&dwResultSize,
pResults,
NULL ); // Not overlapped, must be synchronous
// We now have a raw buffer of results
if ( dwError != ERROR_SUCCESS )
return false;
//
// Skill
//
XUSER_PROFILE_SETTING *pSetting = pResults->pSettings + XPS_GAMER_DIFFICULTY;
Assert( pSetting->data.type == XUSER_DATA_TYPE_INT32 );
int nSkillSetting = pSetting->data.nData;
int nResultSkill = 0;
switch( nSkillSetting )
{
case XPROFILE_GAMER_DIFFICULTY_NORMAL:
nResultSkill = 2;
break;
case XPROFILE_GAMER_DIFFICULTY_HARD:
nResultSkill = 3;
break;
case XPROFILE_GAMER_DIFFICULTY_EASY:
default:
nResultSkill = 1;
break;
}
// If the mod has no difficulty setting, only easy is allowed
KeyValues *modinfo = new KeyValues("ModInfo");
if ( modinfo->LoadFromFile( g_pFileSystem, "gameinfo.txt" ) )
{
if ( stricmp(modinfo->GetString("nodifficulty", "0"), "1") == 0 )
nResultSkill = 1;
}
modinfo->deleteThis();
char szScratch[MAX_PATH];
Q_snprintf( szScratch, sizeof(szScratch), "skill %d", nResultSkill );
Cbuf_AddText( szScratch );
//
// Movement control
//
pSetting = pResults->pSettings + XPS_GAMER_ACTION_MOVEMENT_CONTROL;
Assert( pSetting->data.type == XUSER_DATA_TYPE_INT32 );
Q_snprintf( szScratch, sizeof(szScratch), "joy_movement_stick %d", ( pSetting->data.nData == XPROFILE_ACTION_MOVEMENT_CONTROL_L_THUMBSTICK ) ? 0 : 1 );
Cbuf_AddText( szScratch );
Q_snprintf( szScratch, sizeof(szScratch), "joy_movement_stick_default %d", ( pSetting->data.nData == XPROFILE_ACTION_MOVEMENT_CONTROL_L_THUMBSTICK ) ? 0 : 1 );
Cbuf_AddText( szScratch );
Cbuf_AddText( "joyadvancedupdate" );
//
// Y-Inversion
//
pSetting = pResults->pSettings + XPS_GAMER_YAXIS_INVERSION;
Assert( pSetting->data.type == XUSER_DATA_TYPE_INT32 );
Q_snprintf( szScratch, sizeof(szScratch), "joy_inverty %d", pSetting->data.nData );
Cbuf_AddText( szScratch );
Q_snprintf( szScratch, sizeof(szScratch), "joy_inverty_default %d", pSetting->data.nData );
Cbuf_AddText( szScratch );
//
// Vibration control
//
pSetting = pResults->pSettings + XPS_OPTION_CONTROLLER_VIBRATION;
Assert( pSetting->data.type == XUSER_DATA_TYPE_INT32 );
Q_snprintf( szScratch, sizeof(szScratch), "cl_rumblescale %d", ( pSetting->data.nData != 0 ) ? 1 : 0 );
Cbuf_AddText( szScratch );
// Execute all commands we've queued up
Cbuf_Execute();
#endif // _X360
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Read our configuration from the 360, filling in defaults on our first run
//-----------------------------------------------------------------------------
void Host_ReadConfiguration_360( void )
{
#ifdef _X360
// Exec our defaults on the first pass
if ( g_bConfigCfgExecuted == false )
{
// First, we exec our default configuration for the 360
Cbuf_AddText( "exec config.360.cfg game\n" );
Cbuf_Execute();
}
// Can't do any more in this function if we don't have a valid user id
if ( XBX_GetPrimaryUserId() == INVALID_USER_ID )
return;
// Build the config name we're looking for
char strFileName[MAX_PATH];
Q_snprintf( strFileName, sizeof(strFileName), "cfg:/%s_config.cfg", GetCurrentMod() );
bool bStorageDeviceValid = ( XBX_GetStorageDeviceId() != XBX_INVALID_STORAGE_ID && XBX_GetStorageDeviceId() != XBX_STORAGE_DECLINED );
bool bSaveConfig = false;
// Call through normal API function once the content container is opened
if ( CommandLine()->CheckParm( "-forcexboxreconfig" ) || bStorageDeviceValid == false || g_pFileSystem->FileExists( strFileName ) == false )
{
// If we've already done this in this session, never do it again (we don't want to stomp their settings under any circumstances)
if ( g_bConfigCfgExecuted == false )
{
// Get and set all our default setting we care about from the Xbox
XBX_SetProfileDefaultSettings();
}
// Save out what we have
bSaveConfig = true;
}
else
{
// Otherwise, exec the user settings stored on the 360
char szCommand[MAX_PATH];
Q_snprintf( szCommand, sizeof( szCommand ), "exec %s_config.cfg x360\n", GetCurrentMod() );
Cbuf_AddText( szCommand );
// Exec the video config as well
Q_snprintf( szCommand, sizeof( szCommand ), "exec video_config.cfg x360\n", GetCurrentMod() );
Cbuf_AddText( szCommand );
Cbuf_Execute();
}
// Mark that we've loaded a config and can now save it
g_bConfigCfgExecuted = true;
if ( bSaveConfig )
{
// An ugly hack, but we can probably save this safely
bool saveinit = host_initialized;
host_initialized = true;
Host_WriteConfiguration_360();
host_initialized = saveinit;
}
#endif // _X360
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : false -
//-----------------------------------------------------------------------------
void Host_ReadConfiguration()
{
if ( sv.IsDedicated() )
return;
// Rebind keys and set cvars
if ( !g_pFileSystem )
{
Sys_Error( "Host_ReadConfiguration: g_pFileSystem == NULL\n" );
}
// Handle the 360 case
if ( IsX360() )
{
Host_ReadConfiguration_360();
return;
}
bool saveconfig = false;
ISteamRemoteStorage *pRemoteStorage = SteamClient()?(ISteamRemoteStorage *)SteamClient()->GetISteamGenericInterface(
SteamAPI_GetHSteamUser(), SteamAPI_GetHSteamPipe(), STEAMREMOTESTORAGE_INTERFACE_VERSION ):NULL;
if ( pRemoteStorage )
{
// if cloud settings is default but remote storage does not exist yet, set it to sync all because this is the first
// computer the game is run on--default to copying everything to the cloud
if ( !pRemoteStorage->FileExists( "cfg/config.cfg" ) )
{
DevMsg( "[Cloud]: Default setting with remote data non-existent, sync all\n" );
cl_cloud_settings.SetValue( STEAMREMOTESTORAGE_CLOUD_ON );
}
if ( cl_cloud_settings.GetInt() == STEAMREMOTESTORAGE_CLOUD_ON )
{
// config files are run through the exec command which got pretty complicated with all the splitscreen
// stuff. Steam UFS doens't support split screen well (2 users ?)
GetFileFromRemoteStorage( pRemoteStorage, "cfg/config.cfg", "cfg/config.cfg" );
}
}
if ( g_pFileSystem->FileExists( "//mod/cfg/config.cfg" ) )
{
Cbuf_AddText( "exec config.cfg\n" );
}
else
{
Cbuf_AddText( "exec config_default.cfg\n" );
saveconfig = true;
}
Cbuf_Execute();
if ( pRemoteStorage )
{
if ( cl_cloud_settings.GetInt() == STEAMREMOTESTORAGE_CLOUD_ON )
{
// get logo .VTF file
Q_SetExtension( g_szDefaultLogoFileName, ".vtf", sizeof(g_szDefaultLogoFileName) );
GetFileFromRemoteStorage( pRemoteStorage, g_szDefaultLogoFileName, g_szDefaultLogoFileName );
cl_logofile.SetValue( g_szDefaultLogoFileName );
// get logo .VMT file
Q_SetExtension( g_szDefaultLogoFileName, ".vmt", sizeof(g_szDefaultLogoFileName) );
GetFileFromRemoteStorage( pRemoteStorage, g_szDefaultLogoFileName, g_szDefaultLogoFileName );
}
}
// check to see if we actually set any keys, if not, load defaults from kb_def.lst
// so we at least have basics setup.
int nNumBinds = Key_CountBindings();
if ( nNumBinds == 0 )
{
UseDefaultBindings();
}
else
{
// Setup new bindings - if we ship an update that requires that every user has a key bound for
// X concommand, SetupNewBindings() will do its best to ensure that a key is bound. We assume
// that kb_def.lst includes any bindings that SetupNewBindings() might include in the case
// that nNumBinds == 0 above.
SetupNewBindings();
}
Key_SetBinding( KEY_ESCAPE, "cancelselect" );
// Make sure that something is always bound to console
if (NULL == Key_NameForBinding("toggleconsole"))
{
// If nothing is bound to it then bind it to '
Key_SetBinding( KEY_BACKQUOTE, "toggleconsole" );
}
SetupDefaultAskConnectAcceptKey();
g_bConfigCfgExecuted = true;
if ( saveconfig )
{
// An ugly hack, but we can probably save this safely
bool saveinit = host_initialized;
host_initialized = true;
Host_WriteConfiguration();
host_initialized = saveinit;
}
}
CON_COMMAND( host_writeconfig, "Store current settings to config.cfg (or specified .cfg file)." )
{
if ( args.ArgC() > 3 )
{
ConMsg( "Usage: writeconfig <filename.cfg> [full]\n" );
ConMsg( "<filename.cfg> is required, optionally specify \"full\" to write out all archived convars.\n" );
ConMsg( "By default, only non-default values are written out.\n" );
return;
}
if ( args.ArgC() >= 2 )
{
bool bWriteAll = ( args.ArgC() == 3 && V_stricmp( args[ 2 ], "full" ) == 0 );
char const *filename = args[ 1 ];
if ( !filename || !filename[ 0 ] )
{
return;
}
char outfile[ MAX_QPATH ];
// Strip path and extension from filename
Q_FileBase( filename, outfile, sizeof( outfile ) );
Host_WriteConfiguration( va( "%s.cfg", outfile ), bWriteAll );
if ( !bWriteAll )
ConMsg( "Wrote partial config file \"%s\" out, to write full file use host_writeconfig \"%s\" full\n", outfile, outfile );
}
else
{
Host_WriteConfiguration( NULL, true );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Does a quick parse of the config.cfg to read cvars that
// need to be read before any games systems are initialized
// assumes only cvars and filesystem are initialized
//-----------------------------------------------------------------------------
void Host_ReadPreStartupConfiguration()
{
FileHandle_t f = NULL;
if ( IsX360() )
{
// 360 config is less restrictive and can be anywhere in the game path
f = g_pFileSystem->Open( "//game/cfg/config.360.cfg", "rt" );
}
else
{
f = g_pFileSystem->Open( "//mod/cfg/config.cfg", "rt" );
}
if ( !f )
return;
// read file into memory
int size = g_pFileSystem->Size(f);
char *configBuffer = new char[ size + 1 ];
g_pFileSystem->Read( configBuffer, size, f );
configBuffer[size] = 0;
g_pFileSystem->Close( f );
// parse out file
static const char *s_PreStartupConfigConVars[] =
{
"sv_unlockedchapters", // needed to display the startup graphic while loading
"snd_legacy_surround", // needed to init the sound system
"gameui_xbox", // needed to initialize the correct UI
"save_in_memory" // needed to preread data from the correct location in UI
};
// loop through looking for all the cvars to apply
for (int i = 0; i < ARRAYSIZE(s_PreStartupConfigConVars); i++)
{
const char *search = Q_stristr(configBuffer, s_PreStartupConfigConVars[i]);
if (search)
{
// read over the token
search = COM_Parse(search);
// read the value
COM_Parse(search);
// apply the value
ConVar *var = (ConVar *)g_pCVar->FindVar( s_PreStartupConfigConVars[i] );
if ( var )
{
var->SetValue( com_token );
}
}
}
// free
delete [] configBuffer;
}
void Host_RecomputeSpeed_f( void )
{
ConMsg( "Recomputing clock speed...\n" );
CClockSpeedInit::Init();
ConMsg( "Clock speed: %.0f Mhz\n", CFastTimer::GetClockSpeed() / 1000000.0 );
}
static ConCommand recompute_speed( "recompute_speed", Host_RecomputeSpeed_f, "Recomputes clock speed (for debugging purposes).", FCVAR_CHEAT );
void DTI_Flush_f()
{
DTI_Flush();
ServerDTI_Flush();
}
static ConCommand dti_flush( "dti_flush", DTI_Flush_f, "Write out the datatable instrumentation files (you must run with -dti for this to work)." );
/*
==================
Host_ShutdownServer
This only happens at the end of a game, not between levels
==================
*/
void Host_ShutdownServer( void )
{
if ( !sv.IsActive() )
return;
Host_AllowQueuedMaterialSystem( false );
// clear structures
#if !defined( SWDS )
g_pShadowMgr->LevelShutdown();
#endif
StaticPropMgr()->LevelShutdown();
Host_FreeStateAndWorld( true );
sv.Shutdown();// sv.Shutdown() references some heap memory, so run it before Host_FreeToLowMark()
Host_FreeToLowMark( true );
IGameEvent *event = g_GameEventManager.CreateEvent( "server_shutdown" );
if ( event )
{
event->SetString( "reason", "restart" );
g_GameEventManager.FireEvent( event );
}
g_Log.Close();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
// Output : bool
//-----------------------------------------------------------------------------
void Host_AccumulateTime( float dt )
{
// Accumulate some time
realtime += dt;
bool bUseNormalTickTime = true;
#if !defined(SWDS)
if ( demoplayer->IsPlayingTimeDemo() )
bUseNormalTickTime = false;
#endif
if ( g_bDedicatedServerBenchmarkMode )
bUseNormalTickTime = false;
if ( bUseNormalTickTime )
{
host_frametime = dt;
}
else
{
// Used to help increase reproducibility of timedemos
host_frametime = host_state.interval_per_tick;
}
#if 1
if ( host_framerate.GetFloat() > 0
#if !defined(SWDS)
&& ( CanCheat() || demoplayer->IsPlayingBack() )
#endif
)
{
float fps = host_framerate.GetFloat();
if ( fps > 1 )
{
fps = 1.0f/fps;
}
host_frametime = fps;
#if !defined(SWDS) && defined( REPLAY_ENABLED )
extern IDemoPlayer *g_pReplayDemoPlayer;
if ( demoplayer->IsPlayingBack() && demoplayer == g_pReplayDemoPlayer )
{
// adjust time scale if playing back demo
host_frametime *= demoplayer->GetPlaybackTimeScale();
}
#endif
host_frametime_unbounded = host_frametime;
}
else if (host_timescale.GetFloat() > 0
#if !defined(SWDS)
&& ( CanCheat() || demoplayer->IsPlayingBack() )
#endif
)
{
float fullscale = host_timescale.GetFloat();
#if !defined(SWDS)
if ( demoplayer->IsPlayingBack() )
{
// adjust time scale if playing back demo
fullscale *= demoplayer->GetPlaybackTimeScale();
}
#endif
host_frametime *= fullscale;
host_frametime_unbounded = host_frametime;
#ifndef NO_TOOLFRAMEWORK
if ( CommandLine()->CheckParm( "-tools" ) == NULL )
{
#endif
host_frametime = min( (double)host_frametime, MAX_FRAMETIME * fullscale);
#ifndef NO_TOOLFRAMEWORK
}
#endif
}
else
#ifndef NO_TOOLFRAMEWORK
if ( CommandLine()->CheckParm( "-tools" ) != NULL )
{
host_frametime_unbounded = host_frametime;
}
else
#endif // !NO_TOOLFRAMEWORK
{ // don't allow really long or short frames
host_frametime_unbounded = host_frametime;
host_frametime = min( (double)host_frametime, MAX_FRAMETIME );
host_frametime = max( (double)host_frametime, MIN_FRAMETIME );
}
#endif
// Adjust the client clock very slightly to keep it in line with the server clock.
float adj = cl.GetClockDriftMgr().AdjustFrameTime( host_frametime ) - host_frametime;
host_frametime += adj;
host_frametime_unbounded += adj;
if ( g_pSoundServices ) // not present on linux server
g_pSoundServices->SetSoundFrametime(dt, host_frametime);
}
#define FPS_AVG_FRAC 0.9f
float g_fFramesPerSecond = 0.0f;
/*
==================
Host_PostFrameRate
==================
*/
void Host_PostFrameRate( float frameTime )
{
frameTime = clamp( frameTime, 0.0001f, 1.0f );
float fps = 1.0f / frameTime;
g_fFramesPerSecond = g_fFramesPerSecond * FPS_AVG_FRAC + ( 1.0f - FPS_AVG_FRAC ) * fps;
}
/*
==================
Host_GetHostInfo
==================
*/
void Host_GetHostInfo(float *fps, int *nActive, int *nMaxPlayers, char *pszMap, int maxlen )
{
// Count clients, report
int clients = sv.GetNumClients();
*fps = g_fFramesPerSecond;
*nActive = clients;
if (pszMap)
{
if (sv.m_szMapname && sv.m_szMapname[0])
Q_strncpy(pszMap, sv.m_szMapname, maxlen );
else
pszMap[0] = '\0';
}
*nMaxPlayers = sv.GetMaxClients();
}
static bool AppearsNumeric( char const *in )
{
char const *p = in;
int special[ 3 ];
Q_memset( special, 0, sizeof( special ) );
for ( ; *p; p++ )
{
if ( *p == '-' )
{
special[0]++;
continue;
}
if ( *p == '+' )
{
special[1]++;
continue;
}
if ( *p >= '0' && *p <= '9' )
{
continue;
}
if ( *p == '.' )
{
special[2]++;
continue;
}
return false;
}
// Can't have multiple +, -, or decimals
for ( int i = 0; i < 3; i++ )
{
if ( special[ i ] > 1 )
return false;
}
// can't be + and - at same time
if ( special[ 0 ] && special[ 1 ] )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: If the value is numeric, remove unnecessary trailing zeros
// Input : *invalue -
// Output : char const
//-----------------------------------------------------------------------------
char const * Host_CleanupConVarStringValue( char const *invalue )
{
static char clean[ 256 ];
Q_snprintf( clean, sizeof( clean ), "%s", invalue );
// Don't mess with empty string
// Otherwise, if it appears numeric and has a decimal, try to strip all zeroes after decimal
if ( Q_strlen( clean ) >= 1 && AppearsNumeric( clean ) && Q_strstr( clean, "." ) )
{
char *end = clean + strlen( clean ) - 1;
while ( *end && end >= clean )
{
// Removing trailing zeros
if ( *end != '0' )
{
// Remove decimal, zoo
if ( *end == '.' )
{
if ( end == clean )
{
*end = '0';
}
else
{
*end = 0;
}
}
break;
}
*end-- = 0;
}
}
return clean;
}
int Host_CountVariablesWithFlags( int flags, bool nonDefault )
{
int i = 0;
const ConCommandBase *var;
for ( var = g_pCVar->GetCommands() ; var ; var=var->GetNext() )
{
if ( var->IsCommand() )
continue;
const ConVar *pCvar = ( const ConVar * )var;
if ( !pCvar->IsFlagSet( flags ) )
continue;
// It's == to the default value, don't count
if ( nonDefault && !Q_strcasecmp( pCvar->GetDefault(), pCvar->GetString() ) )
continue;
i++;
}
return i;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : msg -
//-----------------------------------------------------------------------------
void Host_BuildConVarUpdateMessage( NET_SetConVar *cvarMsg, int flags, bool nonDefault )
{
int count = Host_CountVariablesWithFlags( flags, nonDefault );
// Nothing to send
if ( count <= 0 )
return;
// Too many to send, error out and have mod author get a clue.
if ( count > 255 )
{
Sys_Error( "Engine only supports 255 ConVars marked %i\n", flags );
return;
}
const ConCommandBase *var;
for ( var = g_pCVar->GetCommands() ; var ; var=var->GetNext() )
{
if ( var->IsCommand() )
continue;
const ConVar *pCvar = ( const ConVar * )var;
if ( !pCvar->IsFlagSet( flags ) )
continue;
// It's == to the default value, don't count
if ( nonDefault && !Q_strcasecmp( pCvar->GetDefault(), pCvar->GetString() ) )
continue;
NET_SetConVar::cvar_t acvar;
Q_strncpy( acvar.name, pCvar->GetName(), MAX_OSPATH );
Q_strncpy( acvar.value, Host_CleanupConVarStringValue( pCvar->GetString() ), MAX_OSPATH );
cvarMsg->m_ConVars.AddToTail( acvar );
}
// Make sure this count matches original one!!!
Assert( cvarMsg->m_ConVars.Count() == count );
}
#if !defined( SWDS )
// FIXME: move me somewhere more appropriate
void CL_SendVoicePacket(bool bFinal)
{
#if !defined( NO_VOICE )
if ( !Voice_IsRecording() )
return;
CLC_VoiceData voiceMsg;
// Get whatever compressed data there is and and send it.
char uchVoiceData[2048];
voiceMsg.m_DataOut.StartWriting( uchVoiceData, sizeof(uchVoiceData) );
voiceMsg.m_nLength = Voice_GetCompressedData( uchVoiceData, sizeof(uchVoiceData), bFinal ) * 8;
if( !voiceMsg.m_nLength )
return;
voiceMsg.m_DataOut.SeekToBit( voiceMsg.m_nLength ); // set correct writing position
if ( cl.IsActive() )
{
cl.m_NetChannel->SendNetMsg( voiceMsg );
}
#endif
}
#if defined ( _X360 )
void CL_ProcessXboxVoiceData()
{
if ( Audio_GetXVoice() == NULL )
return;
if ( Audio_GetXVoice()->VoiceUpdateData() == true )
{
if ( cl.IsActive() )
{
Audio_GetXVoice()->VoiceSendData( cl.m_NetChannel );
}
}
}
#endif
void CL_ProcessVoiceData()
{
VPROF_BUDGET( "CL_ProcessVoiceData", VPROF_BUDGETGROUP_OTHER_NETWORKING );
#if !defined( NO_VOICE )
Voice_Idle(host_frametime);
CL_SendVoicePacket(false);
#endif
#if defined ( _X360 )
CL_ProcessXboxVoiceData();
#endif
}
#endif
/*
=====================
Host_UpdateScreen
Refresh the screen
=====================
*/
void Host_UpdateScreen( void )
{
#ifndef SWDS
#ifdef _DEBUG
if( r_ForceRestore.GetInt() )
{
ForceMatSysRestore();
r_ForceRestore.SetValue(0);
}
#endif // _DEBUG
// Refresh the screen
SCR_UpdateScreen ();
#endif
}
/*
====================
Host_UpdateSounds
Update sound subsystem and cd audio
====================
*/
void Host_UpdateSounds( void )
{
#if !defined( SWDS )
// update audio
if ( cl.IsActive() )
{
S_Update( &s_AudioState );
}
else
{
S_Update( NULL );
}
#endif
}
/*
==============================
Host_Speeds
==============================
*/
void CFrameTimer::ResetDeltas()
{
for ( int i = 0; i < NUM_FRAME_SEGMENTS; i++ )
{
deltas[ i ] = 0.0f;
}
}
void CFrameTimer::MarkFrame()
{
double frameTime;
double fps;
// ConDMsg("%f %f %f\n", time1, time2, time3 );
float fs_input = (deltas[FRAME_SEGMENT_INPUT])*1000.0;
float fs_client = (deltas[FRAME_SEGMENT_CLIENT])*1000.0;
float fs_server = (deltas[FRAME_SEGMENT_SERVER])*1000.0;
float fs_render = (deltas[FRAME_SEGMENT_RENDER])*1000.0;
float fs_sound = (deltas[FRAME_SEGMENT_SOUND])*1000.0;
float fs_cldll = (deltas[FRAME_SEGMENT_CLDLL])*1000.0;
float fs_exec = (deltas[FRAME_SEGMENT_CMD_EXECUTE])*1000.0;
ResetDeltas();
frameTime = host_frametime;
//frameTime /= 1000.0;
if ( frameTime < 0.0001 )
{
fps = 999.0;
}
else
{
fps = 1.0 / frameTime;
}
if (host_speeds.GetInt())
{
int ent_count = 0;
int i;
static int last_host_tickcount;
int ticks = host_tickcount - last_host_tickcount;
last_host_tickcount = host_tickcount;
// count used entities
for (i=0 ; i<sv.num_edicts ; i++)
{
if (!sv.edicts[i].IsFree())
ent_count++;
}
char sz[ 256 ];
Q_snprintf( sz, sizeof( sz ),
"%3i fps -- inp(%.2f) sv(%.2f) cl(%.2f) render(%.2f) snd(%.2f) cl_dll(%.2f) exec(%.2f) ents(%d) ticks(%d)",
(int)fps,
fs_input,
fs_server,
fs_client,
fs_render,
fs_sound,
fs_cldll,
fs_exec,
ent_count,
ticks );
#ifndef SWDS
if ( host_speeds.GetInt() >= 2 )
{
Con_NPrintf ( 0, sz );
}
else
{
ConDMsg ( "%s\n", sz );
}
#endif
}
}
#define FRAME_TIME_FILTER_TIME 0.5f
void CFrameTimer::ComputeFrameVariability()
{
m_pFrameTimeHistory[m_nFrameTimeHistoryIndex] = frametime;
if ( ++m_nFrameTimeHistoryIndex >= FRAME_HISTORY_COUNT )
{
m_nFrameTimeHistoryIndex = 0;
}
// Compute a low-pass filter of the frame time over the last half-second
// Count the number of samples that live within the last half-second
int i = m_nFrameTimeHistoryIndex;
int nMaxSamples = 0;
float flTotalTime = 0.0f;
while( (nMaxSamples < FRAME_HISTORY_COUNT) && (flTotalTime <= FRAME_TIME_FILTER_TIME) )
{
if ( --i < 0 )
{
i = FRAME_HISTORY_COUNT - 1;
}
if ( m_pFrameTimeHistory[i] == 0.0f )
break;
flTotalTime += m_pFrameTimeHistory[i];
++nMaxSamples;
}
if ( nMaxSamples == 0 )
{
m_flFPSVariability = 0.0f;
m_flFPSStdDeviationSeconds = 0.0f;
return;
}
float flExponent = -2.0f / (int)nMaxSamples;
i = m_nFrameTimeHistoryIndex;
float flAverageTime = 0.0f;
float flExpCurveArea = 0.0f;
int n = 0;
while( n < nMaxSamples )
{
if ( --i < 0 )
{
i = FRAME_HISTORY_COUNT - 1;
}
flExpCurveArea += exp( flExponent * n );
flAverageTime += m_pFrameTimeHistory[i] * exp( flExponent * n );
++n;
}
flAverageTime /= flExpCurveArea;
float flAveFPS = 0.0f;
if ( flAverageTime != 0.0f )
{
flAveFPS = 1.0f / flAverageTime;
}
float flCurrentFPS = 0.0f;
if ( frametime != 0.0f )
{
flCurrentFPS = 1.0f / frametime;
}
// Now subtract out the current fps to get variability in FPS
m_flFPSVariability = fabs( flCurrentFPS - flAveFPS );
// Now compute variance/stddeviation
double sum = 0.0f;
int count =0;
for ( int j = 0; j < FRAME_HISTORY_COUNT; ++j )
{
if ( m_pFrameTimeHistory[ j ] == 0.0f )
continue;
double ft = min( (double)m_pFrameTimeHistory[ j ], 0.25 );
sum += ft;
++count;
}
if ( count <= 1 )
{
return;
}
double avg = sum / (double)count;
double devSquared = 0.0f;
for ( int j = 0; j < FRAME_HISTORY_COUNT; ++j )
{
if ( m_pFrameTimeHistory[ j ] == 0.0f )
continue;
double ft = min( (double)m_pFrameTimeHistory[ j ], 0.25 );
double dt = ft - avg;
devSquared += ( dt * dt );
}
double variance = devSquared / (double)( count - 1 );
m_flFPSStdDeviationSeconds = sqrt( variance );
}
void Host_Speeds()
{
g_HostTimes.MarkFrame();
#if !defined(SWDS)
ToClientDemoPlayer( demoplayer )->MarkFrame( g_HostTimes.m_flFPSVariability );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: When singlestep == 1, then you must set next == 1 to run to the
// next frame.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool Host_ShouldRun( void )
{
static int current_tick = -1;
// See if we are single stepping
if ( !singlestep.GetInt() )
{
return true;
}
// Did user set "next" to 1?
if ( cvarNext.GetInt() )
{
// Did we finally finish this frame ( Host_ShouldRun is called in 3 spots to pause
// three different things ).
if ( current_tick != (host_tickcount-1) )
{
// Okay, time to reset to halt execution again
cvarNext.SetValue( 0 );
return false;
}
// Otherwise, keep running this one frame since we are still finishing this frame
return true;
}
else
{
// Remember last frame without "next" being reset ( time is locked )
current_tick = host_tickcount;
// Time is locked
return false;
}
}
static ConVar mem_periodicdumps( "mem_periodicdumps", "0", 0, "Write periodic memstats dumps every n seconds." );
static double g_flLastPeriodicMemDump = -1.0f;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static float g_TimeLastMemTest;
void Host_CheckDumpMemoryStats( void )
{
if ( mem_test_each_frame.GetBool() )
{
if ( !MemAlloc_CrtCheckMemory() )
{
DebuggerBreakIfDebugging();
Error( "Heap is corrupt\n" );
}
}
else if ( mem_test_every_n_seconds.GetInt() > 0 )
{
float now = Plat_FloatTime();
if ( now - g_TimeLastMemTest > mem_test_every_n_seconds.GetInt() )
{
g_TimeLastMemTest = now;
if ( !MemAlloc_CrtCheckMemory() )
{
DebuggerBreakIfDebugging();
Error( "Heap is corrupt\n" );
}
}
}
if ( mem_periodicdumps.GetFloat() > 0.0f )
{
double curtime = Plat_FloatTime();
if ( curtime - g_flLastPeriodicMemDump > mem_periodicdumps.GetFloat() )
{
const char *pTest = sv.GetMapName();
if ( !pTest || !pTest[0] )
{
// possibly at menu
pTest = "nomap";
}
char mapname[ 256 ];
Q_FileBase( pTest, mapname, sizeof( mapname ) );
#if defined( _MEMTEST )
MemAlloc_SetStatsExtraInfo( pTest, "" );
#endif
MemAlloc_DumpStatsFileBase( mapname );
g_flLastPeriodicMemDump = curtime;
}
}
#if defined(_WIN32)
if ( mem_dumpstats.GetInt() <= 0 )
return;
if ( mem_dumpstats.GetInt() == 1 )
mem_dumpstats.SetValue( 0 ); // reset cvar, dump stats only once
_CrtMemState state;
Q_memset( &state, 0, sizeof( state ) );
_CrtMemCheckpoint( &state );
unsigned int size = 0;
for ( int use = 0; use < _MAX_BLOCKS; use++)
{
size += state.lSizes[ use ];
}
Msg("MEMORY: Run-time Heap\n------------------------------------\n");
Msg( "\tHigh water %s\n", Q_pretifymem( state.lHighWaterCount,4 ) );
Msg( "\tCurrent mem %s\n", Q_pretifymem( size,4 ) );
Msg("------------------------------------\n");
int hunk = Hunk_MallocSize();
Msg("\tAllocated outside hunk: %s\n", Q_pretifymem( size - hunk ) );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void _Host_SetGlobalTime()
{
// Server
g_ServerGlobalVariables.realtime = realtime;
g_ServerGlobalVariables.framecount = host_framecount;
g_ServerGlobalVariables.absoluteframetime = host_frametime;
g_ServerGlobalVariables.interval_per_tick = host_state.interval_per_tick;
g_ServerGlobalVariables.serverCount = Host_GetServerCount();
#ifndef SWDS
// Client
g_ClientGlobalVariables.realtime = realtime;
g_ClientGlobalVariables.framecount = host_framecount;
g_ClientGlobalVariables.absoluteframetime = host_frametime;
g_ClientGlobalVariables.interval_per_tick = host_state.interval_per_tick;
#endif
}
/*
==================
_Host_RunFrame
Runs all active servers
==================
*/
void _Host_RunFrame_Input( float accumulated_extra_samples, bool bFinalTick )
{
VPROF_BUDGET( "_Host_RunFrame_Input", _T("Input") );
// Run a test script?
static bool bFirstFrame = true;
if ( bFirstFrame )
{
bFirstFrame = false;
const char *pScriptFilename = CommandLine()->ParmValue( "-testscript" );
if ( pScriptFilename )
{
if ( !GetTestScriptMgr()->StartTestScript( pScriptFilename ) )
{
Error( "StartTestScript( %s ) failed.", pScriptFilename );
}
}
}
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_INPUT );
#ifndef SWDS
// Client can process input
ClientDLL_ProcessInput( );
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_CMD_EXECUTE );
// process console commands
Cbuf_Execute ();
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_CMD_EXECUTE );
// Send any current movement commands to server and flush reliable buffer even if not moving yet.
CL_Move( accumulated_extra_samples, bFinalTick );
#endif
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_INPUT );
}
void _Host_RunFrame_Server( bool finaltick )
{
VPROF_BUDGET( "_Host_RunFrame_Server", VPROF_BUDGETGROUP_GAME );
VPROF_INCREMENT_COUNTER( "ticks", 1 );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// Run the Server frame ( read, run physics, respond )
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_SERVER );
SV_Frame ( finaltick );
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_SERVER );
// Look for connectionless rcon packets on dedicated servers
// SV_CheckRcom(); TODO
}
void _Host_RunFrame_Server_Async( int numticks )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %d", __FUNCTION__, numticks );
for ( int tick = 0; tick < numticks; tick++ )
{
g_ServerGlobalVariables.tickcount = sv.m_nTickCount;
g_ServerGlobalVariables.simTicksThisFrame = numticks - tick;
bool bFinalTick = ( tick == (numticks - 1) );
_Host_RunFrame_Server( bFinalTick );
}
}
void _Host_RunFrame_Client( bool framefinished )
{
#ifndef SWDS
VPROF( "_Host_RunFrame_Client" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %d", __FUNCTION__, framefinished );
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_CLIENT );
// Get any current state update from server, etc.
CL_ReadPackets( framefinished );
#if defined( VOICE_OVER_IP )
// Send any enqueued voice data to the server
CL_ProcessVoiceData();
#endif // VOICE_OVER_IP
cl.CheckUpdatingSteamResources();
cl.CheckFileCRCsWithServer();
// Resend connection request if needed.
cl.RunFrame();
if ( CL_IsHL2Demo() || CL_IsPortalDemo() ) // don't need sv.IsDedicated() because ded servers don't run this
{
void CL_DemoCheckGameUIRevealTime();
CL_DemoCheckGameUIRevealTime();
}
Steam3Client().RunFrame();
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_CLIENT );
// This takes 1 usec, so it's pretty cheap...
CL_SetPagedPoolInfo();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Used to set limits on certain convars in multiplayer/sv_cheats mode.
// Returns true if it was called recursively and it early-outed.
//-----------------------------------------------------------------------------
bool CheckVarRange_Generic( ConVar *pVar, int minVal, int maxVal )
{
if ( !CanCheat() && !Host_IsSinglePlayerGame() )
{
int clampedValue = clamp( pVar->GetInt(), minVal, maxVal );
if ( clampedValue != pVar->GetInt() )
{
Warning( "sv_cheats=0 prevented changing %s outside of the range [%d,%d] (was %d).\n", pVar->GetName(), minVal, maxVal, pVar->GetInt() );
pVar->SetValue( clampedValue );
}
}
return false;
}
void CheckSpecialCheatVars()
{
static ConVar *mat_picmip = NULL;
if ( !mat_picmip )
mat_picmip = g_pCVar->FindVar( "mat_picmip" );
// In multiplayer, don't allow them to set mat_picmip > 2.
if ( mat_picmip )
CheckVarRange_Generic( mat_picmip, -1, 2 );
CheckVarRange_r_rootlod();
CheckVarRange_r_lod();
HandleServerAllowColorCorrection();
}
void _Host_RunFrame_Render()
{
#ifndef SWDS
VPROF( "_Host_RunFrame_Render" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "_Host_RunFrame_Render" );
CheckSpecialCheatVars();
int nOrgNoRendering = mat_norendering.GetInt();
if ( cl_takesnapshot )
{
// turn off no-rendering mode, if taking screenshot
mat_norendering.SetValue( 0 );
}
// update video if not running in background
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_RENDER );
CL_LatchInterpolationAmount();
{
VPROF( "_Host_RunFrame_Render - UpdateScreen" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "_Host_RunFrame_Render - UpdateScreen" );
Host_UpdateScreen();
}
{
VPROF( "_Host_RunFrame_Render - CL_DecayLights" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "_Host_RunFrame_Render - CL_DecayLights" );
CL_DecayLights ();
}
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_RENDER );
saverestore->OnFrameRendered();
#ifdef USE_SDL
if ( g_pLauncherMgr )
{
g_pLauncherMgr->OnFrameRendered();
}
#endif
mat_norendering.SetValue( nOrgNoRendering );
#endif
}
void CL_FindInterpolatedAddAngle( float t, float& frac, AddAngle **prev, AddAngle **next )
{
int c = cl.addangle.Count();
*prev = NULL;
*next = NULL;
AddAngle *pentry = NULL;
for ( int i = 0; i < c; i++ )
{
AddAngle *entry = &cl.addangle[ i ];
*next = entry;
// Time is earlier
if ( t < entry->starttime )
{
if ( i == 0 )
{
*prev = *next;
frac = 0.0f;
return;
}
// Avoid div by zero
if ( entry->starttime == pentry->starttime )
{
frac = 0.0f;
return;
}
// Time spans the two entries
frac = ( t - pentry->starttime ) / ( entry->starttime - pentry->starttime );
frac = clamp( frac, 0.0f, 1.0f );
return;
}
*prev = *next;
pentry = entry;
}
}
void CL_DiscardOldAddAngleEntries( float t )
{
float killtime = t - host_state.interval_per_tick - 0.1f;
for ( int i = 0; i < cl.addangle.Count(); i++ )
{
AddAngle *p = &cl.addangle[ i ];
if ( p->starttime <= killtime )
{
cl.addangle.Remove( i );
--i;
}
}
// It's safe to reset the master counter once all the entries decay
if ( cl.addangle.Count() == 0 )
{
cl.prevaddangletotal = cl.addangletotal = 0.0f;
}
}
#ifndef SWDS
void CL_ApplyAddAngle()
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
float curtime = cl.GetTime() - host_state.interval_per_tick;
AddAngle *prev = NULL, *next = NULL;
float frac = 0.0f;
float addangletotal = 0.0f;
CL_FindInterpolatedAddAngle( curtime, frac, &prev, &next );
if ( prev && next )
{
addangletotal = prev->total + frac * ( next->total - prev->total );
}
else
{
addangletotal = cl.prevaddangletotal;
}
float amove = addangletotal - cl.prevaddangletotal;
// Update view angles
cl.viewangles[ 1 ] += amove;
// Update client .dll view of angles
g_pClientSidePrediction->SetLocalViewAngles( cl.viewangles );
// Remember last total
cl.prevaddangletotal = addangletotal;
CL_DiscardOldAddAngleEntries( curtime );
}
#endif
void _Host_RunFrame_Sound()
{
#ifndef SWDS
VPROF_BUDGET( "_Host_RunFrame_Sound", VPROF_BUDGETGROUP_OTHER_SOUND );
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_SOUND );
Host_UpdateSounds();
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_SOUND );
#endif
}
float Host_GetSoundDuration( const char *pSample )
{
#ifndef SWDS
if (!sv.IsDedicated())
{
extern float SV_GetSoundDuration(const char *pSample);
extern float AudioSource_GetSoundDuration(CSfxTable *pSfx);
int index = cl.LookupSoundIndex(pSample);
if (index >= 0)
return AudioSource_GetSoundDuration(cl.GetSound(index));
return SV_GetSoundDuration(pSample);
}
#endif
return 0.0f;
}
CON_COMMAND( host_runofftime, "Run off some time without rendering/updating sounds\n" )
{
if ( args.ArgC() != 2 )
{
ConMsg( "Usage: host_runofftime <seconds>\n" );
return;
}
if ( !sv.IsActive() )
{
ConMsg( "host_ruofftime: must be running a server\n" );
return;
}
if ( sv.IsMultiplayer() )
{
ConMsg( "host_ruofftime: only valid in single player\n" );
return;
}
float advanceTime = atof( args[1] );
if ( advanceTime <= 0.0f )
return;
// 15 minutes is a _long_ time!!!
if ( advanceTime > 15.0f * 60.0f )
{
ConMsg( "host_runofftime would run off %.2f minutes!!! ignoring\n",
advanceTime / 60.0f );
return;
}
ConMsg( "Skipping ahead for %f seconds\n", advanceTime );
SCR_UpdateScreen();
SCR_UpdateScreen ();
}
#if !defined( _X360 )
S_API int SteamGameServer_GetIPCCallCount();
#else
S_API int SteamGameServer_GetIPCCallCount() { return 0; }
#endif
void Host_ShowIPCCallCount()
{
// If set to 0 then get out.
if ( host_ShowIPCCallCount.GetInt() == 0 )
return;
static float s_flLastTime = 0;
static int s_nLastTick = host_tickcount;
static int s_nLastFrame = host_framecount;
// Figure out how often they want to update.
double flInterval = 0;
if ( host_ShowIPCCallCount.GetFloat() > 0 )
{
flInterval = 1.0f / host_ShowIPCCallCount.GetFloat();
}
// This is called every frame so increment the frame counter.
double flCurTime = Plat_FloatTime();
if ( flCurTime - s_flLastTime >= flInterval )
{
uint32 callCount;
ISteamClient *pSteamClient = SteamClient();
if ( pSteamClient )
{
callCount = pSteamClient->GetIPCCallCount();
}
else
{
// Ok, we're a dedicated server and we need to use this to get it.
callCount = (uint32)SteamGameServer_GetIPCCallCount();
}
// Avoid a divide by zero.
int frameCount = host_framecount - s_nLastFrame;
int tickCount = host_tickcount - s_nLastTick;
if ( frameCount == 0 || tickCount == 0 )
return;
Msg( "host_ShowIPCCallCount: %d IPC calls in the past [%d frames, %d ticks] Avg: [%.2f/frame, %.2f/tick]\n",
callCount, frameCount, tickCount, (float)callCount / frameCount, (float)callCount / tickCount );
s_flLastTime = flCurTime;
s_nLastTick = host_tickcount;
s_nLastFrame = host_framecount;
}
}
void Host_SetClientInSimulation( bool bInSimulation )
{
#ifndef SWDS
// Tracker 77931: If the game is paused, then lock the client clock at the previous tick boundary
// (otherwise we'll keep interpolating through the "remainder" time causing the paused characters
// to twitch like they have the shakes)
// TODO: Since this rounds down on the frame we paused, we could see a slight backsliding. We could remember the last "remainder" before pause and re-use it and
// set insimulation == false to be mroe exact. We'd still have to deal with the timing difference between
// when pause/unpause happens on the server versus the client
cl.insimulation = bInSimulation || cl.IsPaused();
// Compute absolute/render time stamp
g_ClientGlobalVariables.curtime = cl.GetTime();
g_ClientGlobalVariables.frametime = cl.GetFrameTime();
#endif
}
static ConVar host_Sleep( "host_sleep", "0", FCVAR_CHEAT, "Force the host to sleep a certain number of milliseconds each frame." );
extern ConVar sv_alternateticks;
#define LOG_FRAME_OUTPUT 0
void _Host_RunFrame (float time)
{
MDLCACHE_COARSE_LOCK_(g_pMDLCache);
static double host_remainder = 0.0f;
double prevremainder;
bool shouldrender;
#if defined( RAD_TELEMETRY_ENABLED )
if( g_Telemetry.DemoTickEnd == ( uint32 )-1 )
{
Cbuf_AddText( "quit\n" );
}
#endif
int numticks;
{
// Profile scope specific to the top of this function, protect from setjmp() problems
VPROF( "_Host_RunFrame_Upto_MarkFrame" );
if ( host_checkheap )
{
#if defined(_WIN32)
if ( _heapchk() != _HEAPOK )
{
Sys_Error( "_Host_RunFrame (top): _heapchk() != _HEAPOK\n" );
}
#endif
}
// When playing back a VCR file, don't do host_sleep. That way, if it was recorded with
// host_sleep on, it'll play back way Faster.
if ( host_Sleep.GetInt() && VCRGetMode() != VCR_Playback )
{
Sys_Sleep( host_Sleep.GetInt() );
}
// Slow down the playback?
if ( g_iVCRPlaybackSleepInterval )
{
Sys_Sleep( g_iVCRPlaybackSleepInterval );
}
MapReslistGenerator().RunFrame();
static int lastrunoffsecond = -1;
if ( setjmp ( host_enddemo ) )
return; // demo finished.
// decide the simulation time
Host_AccumulateTime ( time );
_Host_SetGlobalTime();
shouldrender = !sv.IsDedicated();
// FIXME: Could track remainder as fractional ticks instead of msec
prevremainder = host_remainder;
if ( prevremainder < 0 )
prevremainder = 0;
#if !defined(SWDS)
if ( !demoplayer->IsPlaybackPaused() )
#endif
{
host_remainder += host_frametime;
}
numticks = 0; // how many ticks we will simulate this frame
if ( host_remainder >= host_state.interval_per_tick )
{
numticks = (int)( floor( host_remainder / host_state.interval_per_tick ) );
// round to nearest even ending tick in alternate ticks mode so the last
// tick is always simulated prior to updating the network data
// NOTE: alternate ticks only applies in SP!!!
if ( Host_IsSinglePlayerGame() &&
sv_alternateticks.GetBool() )
{
int startTick = g_ServerGlobalVariables.tickcount;
int endTick = startTick + numticks;
endTick = AlignValue( endTick, 2 );
numticks = endTick - startTick;
}
host_remainder -= numticks * host_state.interval_per_tick;
}
host_nexttick = host_state.interval_per_tick - host_remainder;
g_pMDLCache->MarkFrame();
}
{
// Profile scope, protect from setjmp() problems
VPROF( "_Host_RunFrame" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "_Host_RunFrame" );
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_CMD_EXECUTE );
// process console commands
Cbuf_Execute ();
// initialize networking for dedicated server after commandline & autoexec.cfg have been parsed
if ( NET_IsDedicated() && !NET_IsMultiplayer() )
NET_SetMutiplayer( true );
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_CMD_EXECUTE );
// Msg( "Running %i ticks (%f remainder) for frametime %f total %f tick %f delta %f\n", numticks, remainder, host_frametime, host_time );
g_ServerGlobalVariables.interpolation_amount = 0.0f;
#ifndef SWDS
g_ClientGlobalVariables.interpolation_amount = 0.0f;
cl.insimulation = true;
#endif
host_frameticks = numticks;
host_currentframetick = 0;
#if !defined( SWDS )
// This is to make the tool do both sim + rendering on the initial frame
// cl.IsActive changes in the loop below, as does scr_nextdrawtick
// We're just caching off the state here so that we have a consistent return value
// for enginetool->IsInGame the entire frame
g_pEngineToolInternal->SetIsInGame( cl.IsActive() && ( scr_nextdrawtick == 0 ) );
#endif
CJob *pGameJob = NULL;
// threaded path only supported in listen server
#ifndef SWDS
if ( !IsEngineThreaded() )
#endif
{
#ifndef SWDS
if ( g_ClientDLL )
{
g_ClientDLL->IN_SetSampleTime(host_frametime);
}
g_ClientGlobalVariables.simTicksThisFrame = 1;
#endif
cl.m_tickRemainder = host_remainder;
g_ServerGlobalVariables.simTicksThisFrame = 1;
cl.SetFrameTime( host_frametime );
for ( int tick = 0; tick < numticks; tick++ )
{
// Emit an ETW event every simulation frame.
ETWSimFrameMark( sv.IsDedicated() );
double now = Plat_FloatTime();
float jitter = now - host_idealtime;
// Track jitter (delta between ideal time and actual tick execution time)
host_jitterhistory[ host_jitterhistorypos ] = jitter;
host_jitterhistorypos = ( host_jitterhistorypos + 1 ) % ARRAYSIZE(host_jitterhistory);
// Very slowly decay "ideal" towards current wall clock unless delta is large
if ( fabs( jitter ) > 1.0f )
{
host_idealtime = now;
}
else
{
host_idealtime = 0.99 * host_idealtime + 0.01 * now;
}
// process any asynchronous network traffic (TCP), set net_time
NET_RunFrame( now );
// Only send updates on final tick so we don't re-encode network data multiple times per frame unnecessarily
bool bFinalTick = ( tick == (numticks - 1) );
// initialize networking for dedicated server after commandline & autoexec.cfg have been parsed
if ( NET_IsDedicated() && !NET_IsMultiplayer() )
NET_SetMutiplayer( true );
g_ServerGlobalVariables.tickcount = sv.m_nTickCount;
// NOTE: Do we want do this at start or end of this loop?
++host_tickcount;
++host_currentframetick;
#ifndef SWDS
g_ClientGlobalVariables.tickcount = cl.GetClientTickCount();
// Make sure state is correct
CL_CheckClientState();
#endif
//-------------------
// input processing
//-------------------
_Host_RunFrame_Input( prevremainder, bFinalTick );
prevremainder = 0;
//-------------------
//
// server operations
//
//-------------------
_Host_RunFrame_Server( bFinalTick );
// Additional networking ops for SPLITPACKET stuff (99.9% of the time this will be an empty list of work)
NET_SendQueuedPackets();
//-------------------
//
// client operations
//
//-------------------
#ifndef SWDS
if ( !sv.IsDedicated() )
{
_Host_RunFrame_Client( bFinalTick );
}
toolframework->Think( bFinalTick );
#endif
host_idealtime += host_state.interval_per_tick;
}
// run HLTV if active
if ( hltv )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "hltv->RunFrame()" );
hltv->RunFrame();
}
if ( hltvtest )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "hltvtest->RunFrame()" );
hltvtest->RunFrame();
}
#if defined( REPLAY_ENABLED )
// run replay if active
if ( replay )
{
replay->RunFrame();
}
// Update server-side replay history manager
if ( sv.IsDedicated() && g_pServerReplayContext && g_pServerReplayContext->IsInitialized() )
{
g_pServerReplayContext->Think();
}
#endif
#ifndef SWDS
// This is a hack to let timedemo pull messages from the queue faster than every 15 msec
// Also when demoplayer is skipping packets to a certain tick we should process the queue
// as quickly as we can.
if ( numticks == 0 && ( demoplayer->IsPlayingTimeDemo() || demoplayer->IsSkipping() ) )
{
_Host_RunFrame_Client( true );
}
if ( !sv.IsDedicated() )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "Host_SetClientInSimulation" );
// This causes cl.gettime() to return the true clock being used for rendering (tickcount * rate + remainder)
Host_SetClientInSimulation( false );
// Now allow for interpolation on client
g_ClientGlobalVariables.interpolation_amount = ( cl.m_tickRemainder / host_state.interval_per_tick );
#if defined( REPLAY_ENABLED )
// Update client-side replay history manager - called here since interpolation_amount is set
if ( g_pClientReplayContext && g_pClientReplayContext->IsInitialized() )
{
g_pClientReplayContext->Think();
}
#endif
//-------------------
// Run prediction if it hasn't been run yet
//-------------------
// If we haven't predicted/simulated the player (multiplayer with prediction enabled and
// not a listen server with zero frame lag, then go ahead and predict now
CL_RunPrediction( PREDICTION_NORMAL );
CL_ApplyAddAngle();
// The mouse is always simulated for the current frame's time
// This makes updates smooth in every case
// continuous controllers affecting the view are also simulated this way
// but they have a cap applied by IN_SetSampleTime() so they are not also
// simulated during input gathering
CL_ExtraMouseUpdate( g_ClientGlobalVariables.frametime );
}
#endif
#if defined( REPLAY_ENABLED )
// Let the replay system think
if ( g_pReplay )
{
g_pReplay->Think();
}
#endif
#if LOG_FRAME_OUTPUT
if ( !cl.IsPaused() || !sv.IsPaused() )
{
Msg("=============SIM: CLIENT %5d + %d, SERVER %5d + %d\t REM: %.2f\n", cl.GetClientTickCount(), numticks, sv.m_nTickCount, numticks, host_remainder*1000.0f );
}
#endif
}
#ifndef SWDS
else
{
static int numticks_last_frame = 0;
static float host_remainder_last_frame = 0, prev_remainder_last_frame = 0, last_frame_time = 0;
int clientticks;
int serverticks;
clientticks = numticks_last_frame;
cl.m_tickRemainder = host_remainder_last_frame;
cl.SetFrameTime( last_frame_time );
if ( g_ClientDLL )
{
g_ClientDLL->IN_SetSampleTime(last_frame_time);
}
last_frame_time = host_frametime;
serverticks = numticks;
g_ClientGlobalVariables.simTicksThisFrame = clientticks;
g_ServerGlobalVariables.simTicksThisFrame = serverticks;
g_ServerGlobalVariables.tickcount = sv.m_nTickCount;
// THREADED: Run Client
// -------------------
for ( int tick = 0; tick < clientticks; tick++ )
{
// process any asynchronous network traffic (TCP), set net_time
NET_RunFrame( Plat_FloatTime() );
// Only send updates on final tick so we don't re-encode network data multiple times per frame unnecessarily
bool bFinalTick = ( tick == (clientticks - 1) );
// initialize networking for dedicated server after commandline & autoexec.cfg have been parsed
if ( NET_IsDedicated() && !NET_IsMultiplayer() )
NET_SetMutiplayer( true );
g_ClientGlobalVariables.tickcount = cl.GetClientTickCount();
// Make sure state is correct
CL_CheckClientState();
// Additional networking ops for SPLITPACKET stuff (99.9% of the time this will be an empty list of work)
NET_SendQueuedPackets();
//-------------------
//
// client operations
//
//-------------------
if ( !sv.IsDedicated() )
{
_Host_RunFrame_Client( bFinalTick );
}
toolframework->Think( bFinalTick );
}
// This is a hack to let timedemo pull messages from the queue faster than every 15 msec
// Also when demoplayer is skipping packets to a certain tick we should process the queue
// as quickly as we can.
if ( clientticks == 0 && ( demoplayer->IsPlayingTimeDemo() || demoplayer->IsSkipping() ) )
{
_Host_RunFrame_Client( true );
}
// This causes cl.gettime() to return the true clock being used for rendering (tickcount * rate + remainder)
Host_SetClientInSimulation( false );
// Now allow for interpolation on client
g_ClientGlobalVariables.interpolation_amount = ( cl.m_tickRemainder / host_state.interval_per_tick );
//-------------------
// Run prediction if it hasn't been run yet
//-------------------
// If we haven't predicted/simulated the player (multiplayer with prediction enabled and
// not a listen server with zero frame lag, then go ahead and predict now
CL_RunPrediction( PREDICTION_NORMAL );
CL_ApplyAddAngle();
Host_SetClientInSimulation( true );
// THREADED: Run Input
// -------------------
int saveTick = g_ClientGlobalVariables.tickcount;
for ( int tick = 0; tick < serverticks; tick++ )
{
// NOTE: Do we want do this at start or end of this loop?
++host_tickcount;
++host_currentframetick;
g_ClientGlobalVariables.tickcount = host_tickcount;
bool bFinalTick = tick==(serverticks-1) ? true : false;
_Host_RunFrame_Input( prevremainder, bFinalTick );
prevremainder = 0;
// process any asynchronous network traffic (TCP), set net_time
NET_RunFrame( Plat_FloatTime() );
}
Host_SetClientInSimulation( false );
// The mouse is always simulated for the current frame's time
// This makes updates smooth in every case
// continuous controllers affecting the view are also simulated this way
// but they have a cap applied by IN_SetSampleTime() so they are not also
// simulated during input gathering
CL_ExtraMouseUpdate( g_ClientGlobalVariables.frametime );
g_ClientGlobalVariables.tickcount = saveTick;
numticks_last_frame = numticks;
host_remainder_last_frame = host_remainder;
// THREADED: Run Server
// -------------------
// set net_time once before running the server
NET_SetTime( Plat_FloatTime() );
pGameJob = new CFunctorJob( CreateFunctor( _Host_RunFrame_Server_Async, serverticks ) );
if ( IsX360() )
{
pGameJob->SetServiceThread( g_nServerThread );
}
g_pThreadPool->AddJob( pGameJob );
#if LOG_FRAME_OUTPUT
if ( !cl.IsPaused() || !sv.IsPaused() )
{
Msg("=============SIM: CLIENT %5d + %d, SERVER %5d + %d\t REM: %.2f\n", cl.GetClientTickCount(), clientticks, sv.m_nTickCount, serverticks, host_remainder*1000.0f );
}
#endif
}
#endif // SWDS
g_Log.RunFrame();
if ( shouldrender )
{
#if LOG_FRAME_OUTPUT
if ( !cl.IsPaused() || !sv.IsPaused() )
{
static float lastFrameTime = 0;
float frametime = g_ClientGlobalVariables.curtime - lastFrameTime;
Msg("RENDER AT: %6.4f: %.2fms [%.2fms implicit] frametime\n",
g_ClientGlobalVariables.curtime, g_ClientGlobalVariables.frametime*1000.0f, frametime * 1000.0f);
lastFrameTime = g_ClientGlobalVariables.curtime;
}
#endif
//-------------------
// rendering
//-------------------
_Host_RunFrame_Render();
//-------------------
// sound
//-------------------
_Host_RunFrame_Sound();
if ( g_bVCRSingleStep )
{
VCR_EnterPausedState();
}
}
else
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "modelloader->UpdateDynamicModels" );
VPROF( "UpdateDynamicModels" );
CMDLCacheCriticalSection critsec( g_pMDLCache );
modelloader->UpdateDynamicModels();
}
//-------------------
// simulation
//-------------------
g_HostTimes.MarkSwapTime( );
#ifndef SWDS
if ( !sv.IsDedicated() )
{
VPROF( "_Host_RunFrame - ClientDLL_Update" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "_Host_RunFrame - ClientDLL_Update" );
// Client-side simulation
g_HostTimes.StartFrameSegment( FRAME_SEGMENT_CLDLL );
ClientDLL_Update();
g_HostTimes.EndFrameSegment( FRAME_SEGMENT_CLDLL );
}
#endif
if ( pGameJob )
{
{
VPROF_BUDGET( "WaitForAsyncServer", "AsyncServer" );
if ( Host_IsSinglePlayerGame() )
{
// This should change to a YieldWait if the server starts wanting to parallel process. If
// so, will need some route for the server to queue up work it wants to execute outside
// its frame, otherwise some of it would be performed during the yield. Right now
// need to wait for server so we don't stall on queued AI operations (toml 7/3/2007)
pGameJob->ExecuteAndRelease();
}
else
{
pGameJob->WaitForFinishAndRelease();
}
}
SV_FrameExecuteThreadDeferred();
}
//-------------------
// time
//-------------------
Host_Speeds();
Host_UpdateMapList();
host_framecount++;
#if !defined(SWDS)
if ( !demoplayer->IsPlaybackPaused() )
#endif
{
host_time = host_tickcount * host_state.interval_per_tick + cl.m_tickRemainder;
}
Host_PostFrameRate( host_frametime );
if ( host_checkheap )
{
#ifdef _WIN32
if ( _heapchk() != _HEAPOK )
{
Sys_Error( "_Host_RunFrame (bottom): _heapchk() != _HEAPOK\n" );
}
#endif
}
Host_CheckDumpMemoryStats();
GetTestScriptMgr()->CheckPoint( "frame_end" );
} // Profile scope, protect from setjmp() problems
Host_ShowIPCCallCount();
}
/*
==============================
Host_Frame
==============================
*/
void Host_RunFrame( float time )
{
static double timetotal = 0;
static int timecount = 0;
static double timestart = 0;
#ifndef SWDS
if ( !scr_drawloading && sv.IsActive() && cl.IsActive() && !sv.m_bLoadgame)
{
switch ( host_thread_mode.GetInt() )
{
case HTM_DISABLED: g_bThreadedEngine = false; break;
case HTM_DEFAULT: g_bThreadedEngine = ( g_pThreadPool->NumThreads() > 0 ); break;
case HTM_FORCED: g_bThreadedEngine = true; break;
}
}
else
#endif
{
g_bThreadedEngine = false;
}
if ( !host_profile.GetBool() )
{
_Host_RunFrame( time );
return;
}
double time1 = Sys_FloatTime();
_Host_RunFrame( time );
double time2 = Sys_FloatTime();
timetotal += time2 - time1; // time in seconds
timecount++;
if (timecount < 1000)
return;
float fps = 1000/(time2 - timestart);
ConMsg ("host_profile : %i clients, %.1f msec, %.1f fps\n",
sv.GetNumClients(), timetotal, fps );
timecount = 0;
timetotal = 0;
timestart = time2;
}
//-----------------------------------------------------------------------------
// A more secure means of enforcing low violence.
//-----------------------------------------------------------------------------
bool IsLowViolence_Secure()
{
#ifndef DEDICATED
if ( !IsX360() && Steam3Client().SteamApps() )
{
// let Steam determine current violence settings
return Steam3Client().SteamApps()->BIsLowViolence();
}
else if ( IsX360() )
{
// Low violence for the 360 is enabled by the presence of a file.
if ( g_pFileSystem->FileExists( "cfg/violence.cfg" ) )
{
return true;
}
return false;
}
#endif
return false;
}
//-----------------------------------------------------------------------------
// If "User Token 2" exists in HKEY_CURRENT_USER/Software/Valve/Half-Life/Settings
// then we disable gore. Obviously not very secure.
//-----------------------------------------------------------------------------
bool IsLowViolence_Registry()
{
char szSubKey[128];
int nBufferLen;
char szBuffer[128];
bool bReducedGore = false;
memset( szBuffer, 0, 128 );
char const *appname = "Source";
Q_snprintf(szSubKey, sizeof( szSubKey ), "Software\\Valve\\%s\\Settings", appname );
nBufferLen = 127;
Q_strncpy( szBuffer, "", sizeof( szBuffer ) );
Sys_GetRegKeyValue( szSubKey, "User Token 2", szBuffer, nBufferLen, szBuffer );
// Gore reduction active?
bReducedGore = ( Q_strlen( szBuffer ) > 0 ) ? true : false;
if ( !bReducedGore )
{
Sys_GetRegKeyValue( szSubKey, "User Token 3", szBuffer, nBufferLen, szBuffer );
bReducedGore = ( Q_strlen( szBuffer ) > 0 ) ? true : false;
}
char gamedir[MAX_OSPATH];
Q_FileBase( com_gamedir, gamedir, sizeof( gamedir ) );
// also check mod specific directories for LV changes
Q_snprintf(szSubKey, sizeof( szSubKey ), "Software\\Valve\\%s\\%s\\Settings", appname, gamedir );
nBufferLen = 127;
Q_strncpy( szBuffer, "", sizeof( szBuffer ) );
Sys_GetRegKeyValue( szSubKey, "User Token 2", szBuffer, nBufferLen, szBuffer );
if ( Q_strlen( szBuffer ) > 0 )
{
bReducedGore = true;
}
Sys_GetRegKeyValue( szSubKey, "User Token 3", szBuffer, nBufferLen, szBuffer );
if ( Q_strlen( szBuffer ) > 0 )
{
bReducedGore = true;
}
return bReducedGore;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void Host_CheckGore( void )
{
bool bLowViolenceRegistry = false;
bool bLowViolenceSecure = false;
//
// First check the old method of enabling low violence via the registry.
//
#ifdef WIN32
bLowViolenceRegistry = IsLowViolence_Registry();
#endif
//
// Next check the new method of enabling low violence based on country of purchase
// and other means that are inaccessible by the user.
//
if ( GetCurrentMod() && Q_stricmp( GetCurrentMod(), "cstrike" ) != 0 )
bLowViolenceSecure = IsLowViolence_Secure();
//
// If either method says "yes" to low violence, we're in low violence mode.
//
if ( bLowViolenceRegistry || bLowViolenceSecure )
{
g_bLowViolence = true;
if ( bLowViolenceRegistry )
{
violence_hblood.SetValue( 0 );
violence_hgibs.SetValue( 0 );
violence_ablood.SetValue( 0 );
violence_agibs.SetValue( 0 );
}
}
else
{
g_bLowViolence = false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Host_InitProcessor( void )
{
const CPUInformation& pi = *GetCPUInformation();
// Compute Frequency in Mhz:
char* szFrequencyDenomination = "Mhz";
double fFrequency = pi.m_Speed / 1000000.0;
// Adjust to Ghz if nessecary:
if( fFrequency > 1000.0 )
{
fFrequency /= 1000.0;
szFrequencyDenomination = "Ghz";
}
char szFeatureString[256];
Q_strncpy( szFeatureString, pi.m_szProcessorID, sizeof( szFeatureString ) );
Q_strncat( szFeatureString, " ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
if( pi.m_bSSE )
{
if( MathLib_SSEEnabled() ) Q_strncat(szFeatureString, "SSE ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
else Q_strncat(szFeatureString, "(SSE) ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
}
if( pi.m_bSSE2 )
{
if( MathLib_SSE2Enabled() ) Q_strncat(szFeatureString, "SSE2 ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
else Q_strncat(szFeatureString, "(SSE2) ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
}
if( pi.m_bMMX )
{
if( MathLib_MMXEnabled() ) Q_strncat(szFeatureString, "MMX ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
else Q_strncat(szFeatureString, "(MMX) ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
}
if( pi.m_b3DNow )
{
if( MathLib_3DNowEnabled() ) Q_strncat(szFeatureString, "3DNow ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
else Q_strncat(szFeatureString, "(3DNow) ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
}
if( pi.m_bRDTSC ) Q_strncat(szFeatureString, "RDTSC ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
if( pi.m_bCMOV ) Q_strncat(szFeatureString, "CMOV ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
if( pi.m_bFCMOV ) Q_strncat(szFeatureString, "FCMOV ", sizeof( szFeatureString ), COPY_ALL_CHARACTERS );
// Remove the trailing space. There will always be one.
szFeatureString[Q_strlen(szFeatureString)-1] = '\0';
// Dump CPU information:
if( pi.m_nLogicalProcessors == 1 )
{
ConDMsg( "1 CPU, Frequency: %.01f %s, Features: %s\n",
fFrequency,
szFrequencyDenomination,
szFeatureString
);
}
else
{
char buffer[256] = "";
if( pi.m_nPhysicalProcessors != pi.m_nLogicalProcessors )
{
Q_snprintf(buffer, sizeof( buffer ), " (%i physical)", (int) pi.m_nPhysicalProcessors );
}
ConDMsg( "%i CPUs%s, Frequency: %.01f %s, Features: %s\n",
(int)pi.m_nLogicalProcessors,
buffer,
fFrequency,
szFrequencyDenomination,
szFeatureString
);
}
#if defined( _WIN32 )
if ( s_bInitPME )
{
// Initialize the performance monitoring events code.
InitPME();
}
#endif
}
//-----------------------------------------------------------------------------
// Specifically used by the model loading code to mark models
// touched by the current map
//-----------------------------------------------------------------------------
int Host_GetServerCount( void )
{
if (cl.m_nSignonState >= SIGNONSTATE_NEW)
{
// the server count cannot be relied on until the server info message
// the new state guarantees its validity
return cl.m_nServerCount;
}
else if (sv.m_State >= ss_loading)
{
return sv.GetSpawnCount();
}
// this is unfortunate, and happens, but the caller is too early in the protocol or a demo
// cannot identify the correct server count
// return the same count that demo will use
return gHostSpawnCount;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Host_PostInit()
{
if ( serverGameDLL )
{
serverGameDLL->PostInit();
}
#if !defined( SWDS )
if ( g_ClientDLL )
{
g_ClientDLL->PostInit();
}
toolframework->PostInit();
if ( !sv.IsDedicated() )
{
// vgui needs other systems to finalize
EngineVGui()->PostInit();
}
#if defined( LINUX )
const char en_US[] = "en_US.UTF-8";
const char *CurrentLocale = setlocale( LC_ALL, NULL );
if ( !CurrentLocale )
CurrentLocale = "c";
if ( Q_stricmp( CurrentLocale, en_US ) )
{
char MessageText[ 512 ];
V_sprintf_safe( MessageText, "SetLocale('%s') failed. Using '%s'.\n"
"You may have limited glyph support.\n"
"Please install '%s' locale.",
en_US, CurrentLocale, en_US );
SDL_ShowSimpleMessageBox( 0, "Warning", MessageText, GetAssertDialogParent() );
}
#endif // LINUX
#endif
}
void HLTV_Init()
{
Assert ( hltv == NULL );
Assert ( hltvtest == NULL );
}
void HLTV_Shutdown()
{
if ( hltv )
{
hltv->Shutdown();
delete hltv;
hltv = NULL;
}
if ( hltvtest )
{
delete hltvtest;
hltvtest = NULL;
}
}
// Check with steam to see if the requested file (requires full path) is a valid, signed binary
bool DLL_LOCAL Host_IsValidSignature( const char *pFilename, bool bAllowUnknown )
{
#if defined( SWDS ) || defined(_X360)
return true;
#else
if ( sv.IsDedicated() || IsOSX() || IsLinux() )
{
// dedicated servers and Mac and Linux binaries don't check signatures
return true;
}
else
{
if ( Steam3Client().SteamUtils() )
{
SteamAPICall_t hAPICall = Steam3Client().SteamUtils()->CheckFileSignature( pFilename );
bool bAPICallFailed = true;
while ( !Steam3Client().SteamUtils()->IsAPICallCompleted(hAPICall, &bAPICallFailed) )
{
SteamAPI_RunCallbacks();
ThreadSleep( 1 );
}
if( bAPICallFailed )
{
Warning( "CheckFileSignature API call on %s failed", pFilename );
}
else
{
CheckFileSignature_t result;
Steam3Client().SteamUtils()->GetAPICallResult( hAPICall, &result, sizeof(result), result.k_iCallback, &bAPICallFailed );
if( bAPICallFailed )
{
Warning( "CheckFileSignature API call on %s failed\n", pFilename );
}
else
{
if( result.m_eCheckFileSignature == k_ECheckFileSignatureValidSignature || result.m_eCheckFileSignature == k_ECheckFileSignatureNoSignaturesFoundForThisApp )
return true;
if ( bAllowUnknown && result.m_eCheckFileSignature == k_ECheckFileSignatureNoSignaturesFoundForThisFile )
return true;
Warning( "No valid signature found for %s\n", pFilename );
}
}
}
}
return false;
#endif // SWDS
}
// Ask steam if it is ok to load this DLL. Unsigned DLLs should not be loaded unless
// the client is running -insecure (testing a plugin for example)
// This keeps legitimate users with modified binaries from getting VAC banned because of them
bool DLL_LOCAL Host_AllowLoadModule( const char *pFilename, const char *pPathID, bool bAllowUnknown, bool bIsServerOnly /* = false */ )
{
#if defined( SWDS ) || defined ( OSX ) || defined( LINUX )
// dedicated servers and Mac and Linux binaries don't check signatures
return true;
#else
if ( sv.IsDedicated() || bIsServerOnly )
{
// dedicated servers and Mac binaries don't check signatures
return true;
}
else
{
// check signature
bool bSignatureIsValid = false;
// Do we need to do the signature checking? If secure servers are disabled, just skip it.
if ( Host_IsSecureServerAllowed() )
{
if ( Steam3Client().SteamUtils() )
{
char szDllname[512];
V_strncpy( szDllname, pFilename, sizeof(szDllname) );
V_SetExtension( szDllname, g_pModuleExtension, sizeof(szDllname) );
if ( pPathID )
{
char szFullPath[ 512 ];
const char *pFullPath = g_pFileSystem->RelativePathToFullPath( szDllname, pPathID, szFullPath, sizeof(szFullPath) );
if ( !pFullPath )
{
Warning("Can't find %s on disk\n", szDllname );
bSignatureIsValid = false;
}
else
{
bSignatureIsValid = Host_IsValidSignature( pFullPath, bAllowUnknown );
}
}
else
{
bSignatureIsValid = Host_IsValidSignature( szDllname, bAllowUnknown );
}
}
else
{
Warning("Steam is not active, running in -insecure mode.\n");
Host_DisallowSecureServers();
}
}
else
{
Warning("Loading unsigned module %s\nAccess to secure servers is disabled.\n", pFilename );
return true;
}
return bSignatureIsValid;
}
#endif // SWDS
}
bool DLL_LOCAL Host_IsSecureServerAllowed()
{
if ( CommandLine()->FindParm( "-insecure" ) || CommandLine()->FindParm( "-textmode" ) )
g_bAllowSecureServers = false;
return g_bAllowSecureServers;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Host_Init( bool bDedicated )
{
realtime = 0;
host_idealtime = 0;
#if defined(_WIN32)
if ( CommandLine()->FindParm( "-pme" ) )
{
s_bInitPME = true;
}
#endif
if ( Host_IsSecureServerAllowed() )
{
// double check the engine's signature in case it was hooked/modified
if ( !Host_AllowLoadModule( "engine" DLL_EXT_STRING, "EXECUTABLE_PATH", false, bDedicated ) )
{
// not supposed to load this but we will anyway
Host_DisallowSecureServers();
}
}
ThreadPoolStartParams_t startParams;
if ( IsX360() )
{
// 360 overrides defaults, 2 computation threads distributed to core 1 and 2
startParams.nThreads = 2;
startParams.nStackSize = 256*1024;
startParams.fDistribute = TRS_TRUE;
startParams.bUseAffinityTable = true;
startParams.iAffinityTable[0] = XBOX_PROCESSOR_2;
startParams.iAffinityTable[1] = XBOX_PROCESSOR_4;
ThreadSetAffinity( NULL, 1 );
}
if ( g_pThreadPool )
g_pThreadPool->Start( startParams, "CmpJob" );
// From const.h, the loaded game .dll will give us the correct value which is transmitted to the client
host_state.interval_per_tick = DEFAULT_TICK_INTERVAL;
InstallBitBufErrorHandler();
TRACEINIT( Memory_Init(), Memory_Shutdown() );
TRACEINIT( Con_Init(), Con_Shutdown() );
TRACEINIT( Cbuf_Init(), Cbuf_Shutdown() );
TRACEINIT( Cmd_Init(), Cmd_Shutdown() );
TRACEINIT( g_pCVar->Init(), g_pCVar->Shutdown() ); // So we can list cvars with "cvarlst"
#ifndef SWDS
TRACEINIT( V_Init(), V_Shutdown() );
#endif
TRACEINIT( COM_Init(), COM_Shutdown() );
#ifndef SWDS
TRACEINIT( saverestore->Init(), saverestore->Shutdown() );
#endif
TRACEINIT( Filter_Init(), Filter_Shutdown() );
#ifndef SWDS
TRACEINIT( Key_Init(), Key_Shutdown() );
#endif
// Check for special -dev flag
if ( CommandLine()->FindParm( "-dev" ) || ( CommandLine()->FindParm( "-allowdebug" ) && !CommandLine()->FindParm( "-nodev" ) ) )
{
sv_cheats.SetValue( 1 );
developer.SetValue( 1 );
}
#ifdef _DEBUG
developer.SetValue( 1 );
#endif
// Should have read info from steam.inf by now.
Assert( GetSteamInfIDVersionInfo().AppID != k_uAppIdInvalid );
if ( CommandLine()->FindParm( "-nocrashdialog" ) )
{
// stop the various windows error message boxes from showing up (used by the auto-builder so it doesn't block on error)
Sys_NoCrashDialog();
}
TRACEINIT( NET_Init( bDedicated ), NET_Shutdown() );
TRACEINIT( g_GameEventManager.Init(), g_GameEventManager.Shutdown() );
TRACEINIT( sv.Init( bDedicated ), sv.Shutdown() );
#if defined( REPLAY_ENABLED )
if ( Replay_IsSupportedModAndPlatform() )
{
TRACEINIT( ReplaySystem_Init( bDedicated ), ReplaySystem_Shutdown() );
}
#endif
if ( !CommandLine()->FindParm( "-nogamedll" ) )
{
SV_InitGameDLL();
}
TRACEINIT( g_Log.Init(), g_Log.Shutdown() );
TRACEINIT( HLTV_Init(), HLTV_Shutdown() );
ConDMsg( "Heap: %5.2f Mb\n", host_parms.memsize/(1024.0f*1024.0f) );
#if !defined( SWDS )
if ( !bDedicated )
{
TRACEINIT( CL_Init(), CL_Shutdown() );
// NOTE: This depends on the mod search path being set up
TRACEINIT( InitMaterialSystem(), ShutdownMaterialSystem() );
TRACEINIT( modelloader->Init(), modelloader->Shutdown() );
TRACEINIT( StaticPropMgr()->Init(), StaticPropMgr()->Shutdown() );
TRACEINIT( InitStudioRender(), ShutdownStudioRender() );
//startup vgui
TRACEINIT( EngineVGui()->Init(), EngineVGui()->Shutdown() );
TRACEINIT( TextMessageInit(), TextMessageShutdown() );
TRACEINIT( ClientDLL_Init(), ClientDLL_Shutdown() );
TRACEINIT( SCR_Init(), SCR_Shutdown() );
TRACEINIT( R_Init(), R_Shutdown() );
TRACEINIT( Decal_Init(), Decal_Shutdown() );
// hookup interfaces
EngineVGui()->Connect();
}
else
#endif
{
TRACEINIT( InitMaterialSystem(), ShutdownMaterialSystem() );
TRACEINIT( modelloader->Init(), modelloader->Shutdown() );
TRACEINIT( StaticPropMgr()->Init(), StaticPropMgr()->Shutdown() );
TRACEINIT( InitStudioRender(), ShutdownStudioRender() );
TRACEINIT( Decal_Init(), Decal_Shutdown() );
cl.m_nSignonState = SIGNONSTATE_NONE; // disable client
}
#ifndef SWDS
Host_ReadConfiguration();
TRACEINIT( S_Init(), S_Shutdown() );
#endif
// Execute valve.rc
Cbuf_AddText( "exec valve.rc\n" );
#if defined( REPLAY_ENABLED )
// Execute replay.cfg if this is TF and they want to use the replay system
if ( Replay_IsSupportedModAndPlatform() && CommandLine()->CheckParm( "-replay" ) )
{
const char *pConfigName = CommandLine()->ParmValue( "-replay", "replay.cfg" );
Cbuf_AddText( va( "exec %s\n", pConfigName ) );
}
#endif
// Execute mod-specfic settings, without falling back based on search path.
// This lets us set overrides for games while letting mods of those games
// use the default settings.
if ( g_pFileSystem->FileExists( "//mod/cfg/modsettings.cfg" ) )
{
Cbuf_AddText( "exec modsettings.cfg mod\n" );
}
// Mark DLL as active
// eng->SetNextState( InEditMode() ? IEngine::DLL_PAUSED : IEngine::DLL_ACTIVE );
// Deal with Gore Settings
Host_CheckGore();
TelemetryTick();
// Initialize processor subsystem, and print relevant information:
Host_InitProcessor();
// Mark hunklevel at end of startup
Hunk_AllocName( 0, "-HOST_HUNKLEVEL-" );
host_hunklevel = Hunk_LowMark();
#ifdef SOURCE_MT
if ( CommandLine()->FindParm( "-swapcores" ) )
{
g_nMaterialSystemThread = 1;
g_nServerThread = 0;
}
#endif
Host_AllowQueuedMaterialSystem( false );
// Finished initializing
host_initialized = true;
host_checkheap = CommandLine()->FindParm( "-heapcheck" ) ? true : false;
if ( host_checkheap )
{
#if defined( _WIN32 )
if ( _heapchk() != _HEAPOK )
{
Sys_Error( "Host_Init: _heapchk() != _HEAPOK\n" );
}
#endif
}
// go directly to run state with no active game
HostState_Init();
// check for reslist generation
if ( CommandLine()->FindParm( "-makereslists" ) )
{
MapReslistGenerator().StartReslistGeneration();
}
// check for devshot generation
if ( CommandLine()->FindParm( "-makedevshots" ) )
{
DevShotGenerator().StartDevShotGeneration();
}
// if running outside of steam and NOT a dedicated server then phone home (or if "-phonehome" is passed on the command line)
if ( !sv.IsDedicated() || CommandLine()->FindParm( "-phonehome" ) )
{
// In debug, only run this check if -phonehome is on the command line (so a debug build will "just work").
if ( IsDebug() && CommandLine()->FindParm( "-phonehome" ) )
{
phonehome->Init();
phonehome->Message( IPhoneHome::PHONE_MSG_ENGINESTART, NULL );
}
}
#ifndef SWDS
// Rebuild audio caches
if ( !sv.IsDedicated() && S_IsInitted() )
{
if ( !MapReslistGenerator().IsEnabled() )
{
// only build caches if we aren't' generating reslists (you need reslists to make the caches)
extern void CheckCacheBuild();
CheckCacheBuild();
}
}
#endif
Host_PostInit();
EndLoadingUpdates( );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->SetNonInteractiveTempFullscreenBuffer( NULL, MATERIAL_NON_INTERACTIVE_MODE_STARTUP );
pRenderContext->SetNonInteractivePacifierTexture( NULL, 0, 0, 0 );
}
//-----------------------------------------------------------------------------
// Adds hints to the loader to keep resources that are in the transition volume,
// as they may not be part of the next map's reslist.
//-----------------------------------------------------------------------------
void AddTransitionResources( CSaveRestoreData *pSaveData, const char *pLevelName, const char *pLandmarkName )
{
if ( !IsX360() || ( g_pFileSystem->GetDVDMode() != DVDMODE_STRICT ) )
{
return;
}
// get the bit marked for the next level
int transitionMask = 0;
for ( int i = 0; i < pSaveData->levelInfo.connectionCount; i++ )
{
if ( !Q_stricmp( pLevelName, pSaveData->levelInfo.levelList[i].mapName ) && !Q_stricmp( pLandmarkName, pSaveData->levelInfo.levelList[i].landmarkName ) )
{
transitionMask = 1<<i;
break;
}
}
if ( !transitionMask )
{
// nothing to do
return;
}
const char *pModelName;
bool bHasHumans = false;
for ( int i = 0; i < pSaveData->NumEntities(); i++ )
{
if ( pSaveData->GetEntityInfo(i)->flags & transitionMask )
{
// this entity will cross the transition and needs to be preserved
// add to the next map's resource list which effectively keeps it from being purged
// only care about the actual mdl and not any of its dependants
pModelName = pSaveData->GetEntityInfo(i)->modelname.ToCStr();
g_pQueuedLoader->AddMapResource( pModelName );
// humans require a post pass
if ( !bHasHumans && V_stristr( pModelName, "models/humans" ) )
{
bHasHumans = true;
}
}
}
if ( bHasHumans )
{
// the presence of any human entity in the transition needs to ensure all the human mdls stay
int count = modelloader->GetCount();
for ( int i = 0; i < count; i++ )
{
pModelName = modelloader->GetName( modelloader->GetModelForIndex( i ) );
if ( V_stristr( pModelName, "models/humans" ) )
{
g_pQueuedLoader->AddMapResource( pModelName );
}
}
}
}
bool Host_Changelevel( bool loadfromsavedgame, const char *mapname, const char *start )
{
char _startspot[MAX_QPATH];
char *startspot;
char oldlevel[MAX_PATH];
#if !defined(SWDS)
CSaveRestoreData *pSaveData = NULL;
#endif
bool bTransitionBySave = false;
if ( !sv.IsActive() )
{
ConMsg("Only the server may changelevel\n");
return false;
}
#ifndef SWDS
// FIXME: Even needed?
if ( demoplayer->IsPlayingBack() )
{
ConMsg("Changelevel invalid during demo playback\n");
SCR_EndLoadingPlaque();
return false;
}
#endif
#ifndef SWDS
SCR_BeginLoadingPlaque();
// stop sounds (especially looping!)
S_StopAllSounds(true);
#endif
// Prepare new level
sv.InactivateClients();
// The qualified name of the map, excluding path/extension
char szMapName[MAX_PATH] = { 0 };
// The file to load the map from.
char szMapFile[MAX_PATH] = { 0 };
Q_strncpy( szMapName, mapname, sizeof( szMapName ) );
Host_DefaultMapFileName( szMapName, szMapFile, sizeof( szMapFile ) );
// Ask serverDLL to prepare this load
if ( g_iServerGameDLLVersion >= 10 )
{
serverGameDLL->PrepareLevelResources( szMapName, sizeof( szMapName ), szMapFile, sizeof( szMapFile ) );
}
if ( !modelloader->Map_IsValid( szMapFile ) )
{
#ifndef SWDS
SCR_EndLoadingPlaque();
#endif
// We have already inactivated clients at this point due to PrepareLevelResources being blocking, false alarm,
// tell them to reconnect (which doesn't mean full reconnect, just start rejoining the map)
//
// In the likely case that the game DLL tries another map this is harmless, they'll wait on the game server in
// the connect process if its in another level change by time they get there.
sv.ReconnectClients();
return false;
}
// If changing from the same map to the same map, optimize by not closing and reopening
// the packfile which is embedded in the .bsp; we do this by incrementing the packfile's
// refcount via BeginMapAccess()/EndMapAccess() through the base filesystem API.
struct LocalMapAccessScope
{
LocalMapAccessScope() : bEnabled( false ) { }
~LocalMapAccessScope() { if ( bEnabled ) g_pFileSystem->EndMapAccess(); }
bool bEnabled;
};
LocalMapAccessScope mapscope;
if ( V_strcmp( sv.GetMapName(), szMapName ) == 0 )
{
g_pFileSystem->BeginMapAccess();
mapscope.bEnabled = true;
}
g_pFileSystem->AsyncFinishAll();
if ( !start )
startspot = NULL;
else
{
Q_strncpy (_startspot, start, sizeof( _startspot ) );
startspot = _startspot;
}
Warning( "---- Host_Changelevel ----\n" );
CheckForFlushMemory( sv.GetMapName(), szMapName );
#if !defined( SWDS )
// Always save as an xsave if we're on the X360
saverestore->SetIsXSave( IsX360() );
// Add on time passed since the last time we kept track till this transition
int iAdditionalSeconds = g_ServerGlobalVariables.curtime - saverestore->GetMostRecentElapsedTimeSet();
int iElapsedSeconds = saverestore->GetMostRecentElapsedSeconds() + iAdditionalSeconds;
int iElapsedMinutes = saverestore->GetMostRecentElapsedMinutes() + ( iElapsedSeconds / 60 );
saverestore->SetMostRecentElapsedMinutes( iElapsedMinutes );
saverestore->SetMostRecentElapsedSeconds( ( iElapsedSeconds % 60 ) );
if ( bTransitionBySave )
{
char comment[80];
// Pass in the total elapsed time so it gets added to the elapsed time for this map.
serverGameDLL->GetSaveComment(
comment,
sizeof( comment ),
saverestore->GetMostRecentElapsedMinutes(),
saverestore->GetMostRecentElapsedSeconds() );
if ( !saverestore->SaveGameSlot( "_transition", comment, false, true, szMapName, startspot ) )
{
Warning( "Failed to save data for transition\n" );
SCR_EndLoadingPlaque();
return false;
}
// Not going to load a save after the transition, so add this map's elapsed time to the total elapsed time
int totalSeconds = g_ServerGlobalVariables.curtime + saverestore->GetMostRecentElapsedSeconds();
saverestore->SetMostRecentElapsedMinutes( (int)( totalSeconds / 60.0f ) + saverestore->GetMostRecentElapsedMinutes() );
saverestore->SetMostRecentElapsedSeconds( (int)fmod( totalSeconds, 60.0f ) );
}
#endif
Q_strncpy( oldlevel, sv.GetMapName(), sizeof( oldlevel ) );
#if !defined(SWDS)
if ( loadfromsavedgame )
{
if ( !bTransitionBySave )
{
// save the current level's state
saverestore->SaveGameState( true, &pSaveData );
if ( !pSaveData )
{
Warning( "Failed to save data for transition\n" );
SCR_EndLoadingPlaque();
return false;
}
}
// ensure resources in the transition volume stay
AddTransitionResources( pSaveData, szMapName, startspot );
}
#endif
g_pServerPluginHandler->LevelShutdown();
#if !defined(SWDS)
audiosourcecache->LevelShutdown();
#endif
#if !defined(SWDS)
saverestore->FinishAsyncSave();
#endif
if ( sv.RestartOnLevelChange() )
{
Cbuf_Clear();
Cbuf_AddText( "quit\n" );
return false;
}
DownloadListGenerator().OnLevelLoadStart( szMapName );
if ( !sv.SpawnServer( szMapName, szMapFile, startspot ) )
{
#ifndef SWDS
SCR_EndLoadingPlaque();
#endif
return false;
}
#ifndef SWDS
if ( loadfromsavedgame )
{
if ( !bTransitionBySave )
{
// Finish saving gamestate
saverestore->Finish( pSaveData );
}
g_ServerGlobalVariables.curtime = sv.GetTime();
audiosourcecache->LevelInit( szMapName );
g_pServerPluginHandler->LevelInit( szMapName, CM_EntityString(), oldlevel, startspot, true, false );
sv.SetPaused( true ); // pause until client connects
sv.m_bLoadgame = true;
}
else
#endif
{
g_ServerGlobalVariables.curtime = sv.GetTime();
#if !defined(SWDS)
audiosourcecache->LevelInit( szMapName );
#endif
g_pServerPluginHandler->LevelInit( szMapName, CM_EntityString(), NULL, NULL, false, false );
}
SV_ActivateServer();
#if !defined(SWDS)
// Offset stored elapsed time by the current elapsed time for this new map
int maptime = sv.GetTime();
int minutes = (int)( maptime / 60.0f );
int seconds = (int)fmod( maptime, 60.0f );
saverestore->SetMostRecentElapsedMinutes( saverestore->GetMostRecentElapsedMinutes() - minutes );
saverestore->SetMostRecentElapsedSeconds( saverestore->GetMostRecentElapsedSeconds() - seconds );
#endif
NotifyDedicatedServerUI("UpdateMap");
DownloadListGenerator().OnLevelLoadEnd();
return true;
}
/*
===============================================================================
SERVER TRANSITIONS
===============================================================================
*/
bool Host_NewGame( char *mapName, bool loadGame, bool bBackgroundLevel, const char *pszOldMap, const char *pszLandmark, bool bOldSave )
{
VPROF( "Host_NewGame" );
COM_TimestampedLog( "Host_NewGame" );
char previousMapName[MAX_PATH] = { 0 };
Q_strncpy( previousMapName, host_map.GetString(), sizeof( previousMapName ) );
#ifndef SWDS
SCR_BeginLoadingPlaque();
#endif
// The qualified name of the map, excluding path/extension
char szMapName[MAX_PATH] = { 0 };
// The file to load the map from.
char szMapFile[MAX_PATH] = { 0 };
Q_strncpy( szMapName, mapName, sizeof( szMapName ) );
Host_DefaultMapFileName( szMapName, szMapFile, sizeof( szMapFile ) );
// Steam may not have been started yet, ensure it is available to the game DLL before we ask it to prepare level
// resources
SV_InitGameServerSteam();
// Ask serverDLL to prepare this load
if ( g_iServerGameDLLVersion >= 10 )
{
serverGameDLL->PrepareLevelResources( szMapName, sizeof( szMapName ), szMapFile, sizeof( szMapFile ) );
}
if ( !modelloader->Map_IsValid( szMapFile ) )
{
#ifndef SWDS
SCR_EndLoadingPlaque();
#endif
return false;
}
DevMsg( "---- Host_NewGame ----\n" );
host_map.SetValue( szMapName );
CheckForFlushMemory( previousMapName, szMapName );
if (MapReslistGenerator().IsEnabled())
{
// uncache all the materials, so their files get referenced again for the reslists
// undone for now, since we're just trying to get a global reslist, not per-map accurate
// materials->UncacheAllMaterials();
MapReslistGenerator().OnLevelLoadStart(szMapName);
// cache 'em back in!
// materials->CacheUsedMaterials();
}
DownloadListGenerator().OnLevelLoadStart(szMapName);
if ( !loadGame )
{
VPROF( "Host_NewGame_HostState_RunGameInit" );
HostState_RunGameInit();
}
// init network mode
VPROF_SCOPE_BEGIN( "Host_NewGame_SpawnServer" );
NET_SetMutiplayer( sv.IsMultiplayer() );
NET_ListenSocket( sv.m_Socket, true ); // activated server TCP socket
// let's not have any servers with no name
if ( host_name.GetString()[0] == 0 )
{
host_name.SetValue( serverGameDLL->GetGameDescription() );
}
if ( !sv.SpawnServer ( szMapName, szMapFile, NULL ) )
{
return false;
}
sv.m_bIsLevelMainMenuBackground = bBackgroundLevel;
VPROF_SCOPE_END();
// make sure the time is set
g_ServerGlobalVariables.curtime = sv.GetTime();
COM_TimestampedLog( "serverGameDLL->LevelInit" );
#ifndef SWDS
EngineVGui()->UpdateProgressBar(PROGRESS_LEVELINIT);
audiosourcecache->LevelInit( szMapName );
#endif
g_pServerPluginHandler->LevelInit( szMapName, CM_EntityString(), pszOldMap, pszLandmark, loadGame && !bOldSave, bBackgroundLevel );
if ( loadGame && !bOldSave )
{
sv.SetPaused( true ); // pause until all clients connect
sv.m_bLoadgame = true;
g_ServerGlobalVariables.curtime = sv.GetTime();
}
if( !SV_ActivateServer() )
{
return false;
}
// Connect the local client when a "map" command is issued.
if ( !sv.IsDedicated() )
{
COM_TimestampedLog( "Stuff 'connect localhost' to console" );
char str[512];
Q_snprintf( str, sizeof( str ), "connect localhost:%d listenserver", sv.GetUDPPort() );
Cbuf_AddText( str );
}
else
{
// Dedicated server triggers map load here.
GetTestScriptMgr()->CheckPoint( "FinishedMapLoad" );
}
#ifndef SWDS
if ( !loadGame || bOldSave )
{
// clear the most recent remember save, so the level will just restart if the player dies
saverestore->ForgetRecentSave();
}
saverestore->SetMostRecentElapsedMinutes( 0 );
saverestore->SetMostRecentElapsedSeconds( 0 );
#endif
if (MapReslistGenerator().IsEnabled())
{
MapReslistGenerator().OnLevelLoadEnd();
}
DownloadListGenerator().OnLevelLoadEnd();
return true;
}
void Host_FreeStateAndWorld( bool server )
{
bool bNeedsPurge = false;
Assert( host_initialized );
Assert( host_hunklevel );
// If called by the client and we are running a listen server, just ignore
if ( !server && sv.IsActive() )
return;
// HACKHACK: You can't clear the hunk unless the client data is free
// since this gets called by the server, it's necessary to wipe the client
// in case we are on a listen server
#ifndef SWDS
if ( server && !sv.IsDedicated() )
{
CL_ClearState();
}
#endif
// The world model relies on the low hunk, so we need to force it to unload
if ( host_state.worldmodel )
{
modelloader->UnreferenceModel( host_state.worldmodel, IModelLoader::FMODELLOADER_SERVER );
modelloader->UnreferenceModel( host_state.worldmodel, IModelLoader::FMODELLOADER_CLIENT );
host_state.SetWorldModel( NULL );
bNeedsPurge = server && true;
}
// Unload and reset dynamic models
if ( server )
{
extern IVModelInfo* modelinfo;
modelinfo->OnLevelChange();
}
#ifndef SWDS
else
{
extern IVModelInfoClient* modelinfoclient;
modelinfoclient->OnLevelChange();
}
#endif
modelloader->UnloadUnreferencedModels();
g_TimeLastMemTest = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Host_FreeToLowMark( bool server )
{
Assert( host_initialized );
Assert( host_hunklevel );
// If called by the client and we are running a listen server, just ignore
if ( !server && sv.IsActive() )
return;
CM_FreeMap();
if ( host_hunklevel )
{
// See if we are going to obliterate any malloc'd pointers
Hunk_FreeToLowMark(host_hunklevel);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Host_Shutdown(void)
{
extern void ShutdownMixerControls();
if ( host_checkheap )
{
#ifdef _WIN32
if ( _heapchk() != _HEAPOK )
{
Sys_Error( "Host_Shutdown (top): _heapchk() != _HEAPOK\n" );
}
#endif
}
// Check for recursive shutdown, should never happen
static bool shutting_down = false;
if ( shutting_down )
{
Msg( "Recursive shutdown!!!\n" );
return;
}
shutting_down = true;
phonehome->Message( IPhoneHome::PHONE_MSG_ENGINEEND, NULL );
phonehome->Shutdown();
#ifndef SWDS
// Store active configuration settings
Host_WriteConfiguration();
#endif
// Disconnect from server
Host_Disconnect(true);
#ifndef SWDS
// keep ConMsg from trying to update the screen
scr_disabled_for_loading = true;
#endif
#if defined VOICE_OVER_IP && !defined SWDS && !defined( NO_VOICE ) //!defined(_XBOX)
Voice_Deinit();
#endif // VOICE_OVER_IP
// TODO, Trace this
CM_FreeMap();
host_initialized = false;
#if defined(VPROF_ENABLED)
VProfRecord_Shutdown();
#endif
#if !defined SWDS
if ( !sv.IsDedicated() )
{
TRACESHUTDOWN( Decal_Shutdown() );
TRACESHUTDOWN( R_Shutdown() );
TRACESHUTDOWN( SCR_Shutdown() );
TRACESHUTDOWN( S_Shutdown() );
TRACESHUTDOWN( ClientDLL_Shutdown() );
TRACESHUTDOWN( TextMessageShutdown() );
TRACESHUTDOWN( EngineVGui()->Shutdown() );
TRACESHUTDOWN( StaticPropMgr()->Shutdown() );
// Model loader must shutdown before StudioRender
// because it calls into StudioRender
TRACESHUTDOWN( modelloader->Shutdown() );
TRACESHUTDOWN( ShutdownStudioRender() );
TRACESHUTDOWN( ShutdownMaterialSystem() );
TRACESHUTDOWN( CL_Shutdown() );
}
else
#endif
{
TRACESHUTDOWN( Decal_Shutdown() );
TRACESHUTDOWN( modelloader->Shutdown() );
TRACESHUTDOWN( ShutdownStudioRender() );
TRACESHUTDOWN( StaticPropMgr()->Shutdown() );
TRACESHUTDOWN( ShutdownMaterialSystem() );
}
#if defined( REPLAY_ENABLED )
if ( Replay_IsSupportedModAndPlatform() )
{
TRACESHUTDOWN( ReplaySystem_Shutdown() );
}
#endif
TRACESHUTDOWN( HLTV_Shutdown() );
TRACESHUTDOWN( g_Log.Shutdown() );
TRACESHUTDOWN( g_GameEventManager.Shutdown() );
TRACESHUTDOWN( sv.Shutdown() );
TRACESHUTDOWN( NET_Shutdown() );
#ifndef SWDS
TRACESHUTDOWN( Key_Shutdown() );
#ifndef _X360
TRACESHUTDOWN( ShutdownMixerControls() );
#endif
#endif
TRACESHUTDOWN( Filter_Shutdown() );
#ifndef SWDS
TRACESHUTDOWN( saverestore->Shutdown() );
#endif
TRACESHUTDOWN( COM_Shutdown() );
// TRACESHUTDOWN( Host_ShutdownVCR() );
#ifndef SWDS
TRACESHUTDOWN( V_Shutdown() );
#endif
TRACESHUTDOWN( g_pCVar->Shutdown() );
TRACESHUTDOWN( Cmd_Shutdown() );
TRACESHUTDOWN( Cbuf_Shutdown() );
TRACESHUTDOWN( Con_Shutdown() );
TRACESHUTDOWN( Memory_Shutdown() );
if ( g_pThreadPool )
g_pThreadPool->Stop();
DTI_Term();
ServerDTI_Term();
#if defined(_WIN32)
if ( s_bInitPME )
{
ShutdownPME();
}
#endif
if ( host_checkheap )
{
#ifdef _WIN32
if ( _heapchk() != _HEAPOK )
{
Sys_Error( "Host_Shutdown (bottom): _heapchk() != _HEAPOK\n" );
}
#endif
}
}
//-----------------------------------------------------------------------------
// Centralize access to enabling QMS.
//-----------------------------------------------------------------------------
bool Host_AllowQueuedMaterialSystem( bool bAllow )
{
#if !defined DEDICATED
// g_bAllowThreadedSound = bAllow;
// NOTE: Moved this to materialsystem for integrating with other mqm changes
return g_pMaterialSystem->AllowThreading( bAllow, g_nMaterialSystemThread );
#endif
return false;
}