5029 lines
130 KiB
C++
5029 lines
130 KiB
C++
//========= 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>
|
|
|
|
#ifdef USE_SDL
|
|
#include "SDL.h"
|
|
#endif
|
|
#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;
|
|
}
|