d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
200 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 447d80b76f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '447d80b76f'
${ noResults }
source-engine/engine/sys_dll2.cpp

2572 lines
71 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#define DISABLE_PROTECTED_THINGS
#if defined( USE_SDL )
#include "appframework/ilaunchermgr.h"
#endif
#if defined( _WIN32 ) && !defined( _X360 )
#include "winlite.h"
#include <Psapi.h>
#endif
#if defined( OSX )
#include <sys/sysctl.h>
#endif
#if defined( POSIX )
#include <setjmp.h>
#include <signal.h>
#endif
#include <stdarg.h>
#include "quakedef.h"
#include "idedicatedexports.h"
#include "engine_launcher_api.h"
#include "ivideomode.h"
#include "common.h"
#include "iregistry.h"
#include "keys.h"
#include "cdll_engine_int.h"
#include "traceinit.h"
#include "iengine.h"
#include "igame.h"
#include "tier0/etwprof.h"
#include "tier0/vcrmode.h"
#include "tier0/icommandline.h"
#include "tier0/minidump.h"
#include "engine_hlds_api.h"
#include "filesystem_engine.h"
#include "cl_main.h"
#include "client.h"
#include "tier3/tier3.h"
#include "MapReslistGenerator.h"
#include "toolframework/itoolframework.h"
#include "sourcevr/isourcevirtualreality.h"
#include "DevShotGenerator.h"
#include "gl_shader.h"
#include "l_studio.h"
#include "IHammer.h"
#include "sys_dll.h"
#include "materialsystem/materialsystem_config.h"
#include "server.h"
#include "video/ivideoservices.h"
#include "datacache/idatacache.h"
#include "vphysics_interface.h"
#include "inputsystem/iinputsystem.h"
#include "appframework/IAppSystemGroup.h"
#include "tier0/systeminformation.h"
#include "host_cmd.h"
#ifdef _WIN32
#include "VGuiMatSurface/IMatSystemSurface.h"
#endif
#ifdef GPROFILER
#include "gperftools/profiler.h"
#endif
// This is here just for legacy support of older .dlls!!!
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "eiface.h"
#include "tier1/fmtstr.h"
#include "steam/steam_api.h"
#ifndef SWDS
#include "sys_mainwind.h"
#include "vgui/ISystem.h"
#include "vgui_controls/Controls.h"
#include "IGameUIFuncs.h"
#include "cl_steamauth.h"
#endif // SWDS
#if defined(_WIN32)
#include <eh.h>
#endif
#if POSIX
#include <dlfcn.h>
#endif
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#else
#include "xbox/xboxstubs.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#include "tier0/memalloc.h"
//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------
IDedicatedExports *dedicated = NULL;
extern CreateInterfaceFn g_AppSystemFactory;
IHammer *g_pHammer = NULL;
IPhysics *g_pPhysics = NULL;
ISourceVirtualReality *g_pSourceVR = NULL;
#if defined( USE_SDL )
ILauncherMgr *g_pLauncherMgr = NULL;
#endif
#ifndef SWDS
extern CreateInterfaceFn g_ClientFactory;
#endif
static SteamInfVersionInfo_t g_SteamInfIDVersionInfo;
const SteamInfVersionInfo_t& GetSteamInfIDVersionInfo()
{
Assert( g_SteamInfIDVersionInfo.AppID != k_uAppIdInvalid );
return g_SteamInfIDVersionInfo;
}
int build_number( void )
{
return GetSteamInfIDVersionInfo().ServerVersion;
}
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
void Host_GetHostInfo(float *fps, int *nActive, int *nMaxPlayers, char *pszMap, int maxlen );
const char *Key_BindingForKey( int keynum );
void COM_ShutdownFileSystem( void );
void COM_InitFilesystem( const char *pFullModPath );
void Host_ReadPreStartupConfiguration();
//-----------------------------------------------------------------------------
// ConVars and console commands
//-----------------------------------------------------------------------------
#ifndef SWDS
//-----------------------------------------------------------------------------
// Purpose: exports an interface that can be used by the launcher to run the engine
// this is the exported function when compiled as a blob
//-----------------------------------------------------------------------------
void EXPORT F( IEngineAPI **api )
{
CreateInterfaceFn factory = Sys_GetFactoryThis(); // This silly construction is necessary to prevent the LTCG compiler from crashing.
*api = ( IEngineAPI * )(factory(VENGINE_LAUNCHER_API_VERSION, NULL));
}
#endif // SWDS
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ClearIOStates( void )
{
#ifndef SWDS
if ( g_ClientDLL )
{
g_ClientDLL->IN_ClearStates();
}
#endif
}
//-----------------------------------------------------------------------------
// The SDK launches the game with the full path to gameinfo.txt, so we need
// to strip off the path.
//-----------------------------------------------------------------------------
const char *GetModDirFromPath( const char *pszPath )
{
char *pszSlash = Q_strrchr( pszPath, '\\' );
if ( pszSlash )
{
return pszSlash + 1;
}
else if ( ( pszSlash = Q_strrchr( pszPath, '/' ) ) != NULL )
{
return pszSlash + 1;
}
// Must just be a mod directory already.
return pszPath;
}
//-----------------------------------------------------------------------------
// Purpose: Main entry
//-----------------------------------------------------------------------------
#ifndef SWDS
#include "gl_matsysiface.h"
#endif
//-----------------------------------------------------------------------------
// Inner loop: initialize, shutdown main systems, load steam to
//-----------------------------------------------------------------------------
class CModAppSystemGroup : public CAppSystemGroup
{
typedef CAppSystemGroup BaseClass;
public:
// constructor
CModAppSystemGroup( bool bServerOnly, CAppSystemGroup *pParentAppSystem = NULL )
: BaseClass( pParentAppSystem ),
m_bServerOnly( bServerOnly )
{
}
CreateInterfaceFn GetFactory()
{
return CAppSystemGroup::GetFactory();
}
// Methods of IApplication
virtual bool Create();
virtual bool PreInit();
virtual int Main();
virtual void PostShutdown();
virtual void Destroy();
private:
bool IsServerOnly() const
{
return m_bServerOnly;
}
bool ModuleAlreadyInList( CUtlVector< AppSystemInfo_t >& list, const char *moduleName, const char *interfaceName );
bool AddLegacySystems();
bool m_bServerOnly;
};
#if defined( STAGING_ONLY )
CON_COMMAND( bigalloc, "huge alloc crash" )
{
Msg( "pre-crash %d\n", MemAlloc_MemoryAllocFailed() );
// Alloc a bit less than UINT_MAX so there is room for heap headers in the malloc functions.
void *buf = malloc( UINT_MAX - 0x4000 );
Msg( "post-alloc %d. buf: %p\n", MemAlloc_MemoryAllocFailed(), buf );
*(int *)buf = 0;
}
#endif
extern void S_ClearBuffer();
extern char g_minidumpinfo[ 4096 ];
extern PAGED_POOL_INFO_t g_pagedpoolinfo;
extern bool g_bUpdateMinidumpComment;
void GetSpew( char *buf, size_t buflen );
extern int gHostSpawnCount;
extern int g_nMapLoadCount;
extern int g_HostServerAbortCount;
extern int g_HostErrorCount;
extern int g_HostEndDemo;
// Turn this to 1 to allow for expanded spew in minidump comments.
static ConVar sys_minidumpexpandedspew( "sys_minidumpexpandedspew", "1" );
#ifdef IS_WINDOWS_PC
extern "C" void __cdecl FailSafe( unsigned int uStructuredExceptionCode, struct _EXCEPTION_POINTERS * pExceptionInfo )
{
// Nothing, this just catches a crash when creating the comment block
}
#endif
#if defined( POSIX )
static sigjmp_buf g_mark;
static void posix_signal_handler( int i )
{
siglongjmp( g_mark, -1 );
}
#define DO_TRY if ( sigsetjmp( g_mark, 1 ) == 0 )
#define DO_CATCH else
#if defined( OSX )
#define __sighandler_t sig_t
#endif
#else
#define DO_TRY try
#define DO_CATCH catch ( ... )
#endif // POSIX
//-----------------------------------------------------------------------------
// Purpose: Check whether any mods are loaded.
// Currently looks for metamod and sourcemod.
//-----------------------------------------------------------------------------
static bool IsSourceModLoaded()
{
#if defined( _WIN32 )
static const char *s_pFileNames[] = { "metamod.2.tf2.dll", "sourcemod.2.tf2.dll", "sdkhooks.ext.2.ep2v.dll", "sdkhooks.ext.2.tf2.dll" };
for ( size_t i = 0; i < Q_ARRAYSIZE( s_pFileNames ); i++ )
{
// GetModuleHandle function returns a handle to a mapped module
// without incrementing its reference count.
if ( GetModuleHandleA( s_pFileNames[ i ] ) )
return true;
}
#else
FILE *fh = fopen( "/proc/self/maps", "r" );
if ( fh )
{
char buf[ 1024 ];
static const char *s_pFileNames[] = { "metamod.2.tf2.so", "sourcemod.2.tf2.so", "sdkhooks.ext.2.ep2v.so", "sdkhooks.ext.2.tf2.so" };
while ( fgets( buf, sizeof( buf ), fh ) )
{
for ( size_t i = 0; i < Q_ARRAYSIZE( s_pFileNames ); i++ )
{
if ( strstr( buf, s_pFileNames[ i ] ) )
{
fclose( fh );
return true;
}
}
}
fclose( fh );
}
#endif
return false;
}
template< int _SIZE >
class CErrorText
{
public:
CErrorText() : m_bIsDedicatedServer( false ) {}
~CErrorText() {}
void Steam_SetMiniDumpComment()
{
#if !defined( NO_STEAM )
SteamAPI_SetMiniDumpComment( m_errorText );
#endif
}
void CommentCat( const char * str )
{
V_strcat_safe( m_errorText, str );
}
void CommentPrintf( const char *fmt, ... )
{
va_list args;
va_start( args, fmt );
size_t len = strlen( m_errorText );
vsnprintf( m_errorText + len, sizeof( m_errorText ) - len - 1, fmt, args );
m_errorText[ sizeof( m_errorText ) - 1 ] = 0;
va_end( args );
}
void BuildComment( char const *pchSysErrorText, bool bRealCrash )
{
// Try and detect whether this
bool bSourceModLoaded = false;
if ( m_bIsDedicatedServer )
{
bSourceModLoaded = IsSourceModLoaded();
if ( bSourceModLoaded )
{
AppId_t AppId = GetSteamInfIDVersionInfo().ServerAppID;
// Bump up the number and report the crash. This should be something
// like 232251 (instead of 232250). 232251 is for the TF2 Windows client,
// but we actually report those crashes under ID 440, so this should be ok.
SteamAPI_SetBreakpadAppID( AppId + 1 );
}
}
#ifdef IS_WINDOWS_PC
// This warning only applies if you want to catch structured exceptions (crashes)
// using C++ exceptions. We do not want to do that so we can build with C++ exceptions
// completely disabled, and just suppress this warning.
// warning C4535: calling _set_se_translator() requires /EHa
#pragma warning( suppress : 4535 )
_se_translator_function curfilter = _set_se_translator( &FailSafe );
#elif defined( POSIX )
// Only need to worry about this function crashing when we're dealing with a real crash.
__sighandler_t curfilter = bRealCrash ? signal( SIGSEGV, posix_signal_handler ) : 0;
#endif
DO_TRY
{
Q_memset( m_errorText, 0x00, sizeof( m_errorText ) );
if ( pchSysErrorText )
{
CommentCat( "Sys_Error( " );
CommentCat( pchSysErrorText );
// Trim trailing \n.
int len = V_strlen( m_errorText );
if ( len > 0 && m_errorText[ len - 1 ] == '\n' )
m_errorText[ len - 1 ] = 0;
CommentCat( " )\n" );
}
else
{
CommentCat( "Crash\n" );
}
CommentPrintf( "Uptime( %f )\n", Plat_FloatTime() );
CommentPrintf( "SourceMod:%d,DS:%d,Crash:%d\n\n", bSourceModLoaded, m_bIsDedicatedServer, bRealCrash );
// Add g_minidumpinfo from CL_SetSteamCrashComment().
CommentCat( g_minidumpinfo );
// Latch in case extended stuff below crashes
Steam_SetMiniDumpComment();
// Add Memory Status
BuildCommentMemStatus();
// Spew out paged pool stuff, etc.
PAGED_POOL_INFO_t ppi_info;
if ( Plat_GetPagedPoolInfo( &ppi_info ) != SYSCALL_UNSUPPORTED )
{
CommentPrintf( "\nPaged Pool\nprev PP PAGES: used: %lu, free %lu\nfinal PP PAGES: used: %lu, free %lu\n",
g_pagedpoolinfo.numPagesUsed, g_pagedpoolinfo.numPagesFree,
ppi_info.numPagesUsed, ppi_info.numPagesFree );
}
CommentPrintf( "memallocfail? = %u\nActive: %s\nSpawnCount %d MapLoad Count %d\nError count %d, end demo %d, abort count %d\n",
MemAlloc_MemoryAllocFailed(),
( game && game->IsActiveApp() ) ? "active" : "inactive",
gHostSpawnCount,
g_nMapLoadCount,
g_HostErrorCount,
g_HostEndDemo,
g_HostServerAbortCount );
// Latch in case extended stuff below crashes
Steam_SetMiniDumpComment();
// Add user comment strings. 4096 is just a large sanity number we should
// never ever reach (currently our minidump supports 32 of these.)
for( int i = 0; i < 4096; i++ )
{
const char *pUserStreamInfo = MinidumpUserStreamInfoGet( i );
if( !pUserStreamInfo )
break;
if ( pUserStreamInfo[ 0 ] )
CommentPrintf( "%s", pUserStreamInfo );
}
bool bExtendedSpew = sys_minidumpexpandedspew.GetBool();
if ( bExtendedSpew )
{
BuildCommentExtended();
Steam_SetMiniDumpComment();
#if defined( LINUX )
if ( bRealCrash )
{
// bRealCrash is set when we're actually making a comment for a dump or error.
AddFileToComment( "/proc/meminfo" );
AddFileToComment( "/proc/self/status" );
Steam_SetMiniDumpComment();
// Useful, but really big, so disable for now.
//$ AddFileToComment( "/proc/self/maps" );
}
#endif
}
}
DO_CATCH
{
// Oh oh
}
#ifdef IS_WINDOWS_PC
_set_se_translator( curfilter );
#elif defined( POSIX )
if ( bRealCrash )
signal( SIGSEGV, curfilter );
#endif
}
void BuildCommentMemStatus()
{
#ifdef _WIN32
const double MbDiv = 1024.0 * 1024.0;
MEMORYSTATUSEX memStat;
ZeroMemory( &memStat, sizeof( MEMORYSTATUSEX ) );
memStat.dwLength = sizeof( MEMORYSTATUSEX );
if ( GlobalMemoryStatusEx( &memStat ) )
{
CommentPrintf( "\nMemory\nmemusage( %d %% )\ntotalPhysical Mb(%.2f)\nfreePhysical Mb(%.2f)\ntotalPaging Mb(%.2f)\nfreePaging Mb(%.2f)\ntotalVirtualMem Mb(%.2f)\nfreeVirtualMem Mb(%.2f)\nextendedVirtualFree Mb(%.2f)\n",
memStat.dwMemoryLoad,
(double)memStat.ullTotalPhys / MbDiv,
(double)memStat.ullAvailPhys / MbDiv,
(double)memStat.ullTotalPageFile / MbDiv,
(double)memStat.ullAvailPageFile / MbDiv,
(double)memStat.ullTotalVirtual / MbDiv,
(double)memStat.ullAvailVirtual / MbDiv,
(double)memStat.ullAvailExtendedVirtual / MbDiv);
}
HINSTANCE hInst = LoadLibrary( "Psapi.dll" );
if ( hInst )
{
typedef BOOL (WINAPI *GetProcessMemoryInfoFn)(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD);
GetProcessMemoryInfoFn fn = (GetProcessMemoryInfoFn)GetProcAddress( hInst, "GetProcessMemoryInfo" );
if ( fn )
{
PROCESS_MEMORY_COUNTERS counters;
ZeroMemory( &counters, sizeof( PROCESS_MEMORY_COUNTERS ) );
counters.cb = sizeof( PROCESS_MEMORY_COUNTERS );
if ( fn( GetCurrentProcess(), &counters, sizeof( PROCESS_MEMORY_COUNTERS ) ) )
{
CommentPrintf( "\nProcess Memory\nWorkingSetSize Mb(%.2f)\nQuotaPagedPoolUsage Mb(%.2f)\nQuotaNonPagedPoolUsage: Mb(%.2f)\nPagefileUsage: Mb(%.2f)\n",
(double)counters.WorkingSetSize / MbDiv,
(double)counters.QuotaPagedPoolUsage / MbDiv,
(double)counters.QuotaNonPagedPoolUsage / MbDiv,
(double)counters.PagefileUsage / MbDiv );
}
}
FreeLibrary( hInst );
}
#elif defined( OSX )
static const struct
{
int ctl;
const char *name;
} s_ctl_names[] =
{
#define _XTAG( _x ) { _x, #_x }
_XTAG( HW_PHYSMEM ),
_XTAG( HW_USERMEM ),
_XTAG( HW_MEMSIZE ),
_XTAG( HW_AVAILCPU ),
#undef _XTAG
};
for ( size_t i = 0; i < Q_ARRAYSIZE( s_ctl_names ); i++ )
{
uint64_t val = 0;
size_t len = sizeof( val );
int mib[] = { CTL_HW, s_ctl_names[ i ].ctl };
if ( sysctl( mib, Q_ARRAYSIZE( mib ), &val, &len, NULL, 0 ) == 0 )
{
CommentPrintf( " %s: %" PRIu64 "\n", s_ctl_names[ i ].name, val );
}
}
#endif
}
void BuildCommentExtended()
{
try
{
CommentCat( "\nConVars (non-default)\n\n" );
CommentPrintf( "%s %s %s\n", "var", "value", "default" );
for ( const ConCommandBase *var = g_pCVar->GetCommands() ; var ; var = var->GetNext())
{
if ( var->IsCommand() )
continue;
ConVar *pCvar = ( ConVar * )var;
if ( pCvar->IsFlagSet( FCVAR_SERVER_CANNOT_QUERY | FCVAR_PROTECTED ) )
continue;
if ( !(pCvar->IsFlagSet( FCVAR_NEVER_AS_STRING ) ) )
{
char var1[ MAX_OSPATH ];
char var2[ MAX_OSPATH ];
Q_strncpy( var1, Host_CleanupConVarStringValue( pCvar->GetString() ), sizeof( var1 ) );
Q_strncpy( var2, Host_CleanupConVarStringValue( pCvar->GetDefault() ), sizeof( var2 ) );
if ( !Q_stricmp( var1, var2 ) )
continue;
}
else
{
if ( pCvar->GetFloat() == Q_atof( pCvar->GetDefault() ) )
continue;
}
if ( !(pCvar->IsFlagSet( FCVAR_NEVER_AS_STRING ) ) )
CommentPrintf( "%s '%s' '%s'\n", pCvar->GetName(), Host_CleanupConVarStringValue( pCvar->GetString() ), pCvar->GetDefault() );
else
CommentPrintf( "%s '%f' '%f'\n", pCvar->GetName(), pCvar->GetFloat(), Q_atof( pCvar->GetDefault() ) );
}
CommentCat( "\nConsole History (reversed)\n\n" );
// Get console
int len = V_strlen( m_errorText );
if ( len < sizeof( m_errorText ) )
{
GetSpew( m_errorText + len, sizeof( m_errorText ) - len - 1 );
m_errorText[ sizeof( m_errorText ) - 1 ] = 0;
}
}
catch ( ... )
{
CommentCat( "Exception thrown building console/convar history.\n" );
}
}
#if defined( LINUX )
void AddFileToComment( const char *filename )
{
CommentPrintf( "\n%s:\n", filename );
int nStart = Q_strlen( m_errorText );
int nMaxLen = sizeof( m_errorText ) - nStart - 1;
if ( nMaxLen > 0 )
{
FILE *fh = fopen( filename, "r" );
if ( fh )
{
size_t ret = fread( m_errorText + nStart, 1, nMaxLen, fh );
fclose( fh );
// Replace tab characters with spaces.
for ( size_t i = 0; i < ret; i++ )
{
if ( m_errorText[ nStart + i ] == '\t' )
m_errorText[ nStart + i ] = ' ';
}
}
// Entire buffer should have been zeroed out, but just super sure...
m_errorText[ sizeof( m_errorText ) - 1 ] = 0;
}
}
#endif // LINUX
public:
char m_errorText[ _SIZE ];
bool m_bIsDedicatedServer;
};
#if defined( _X360 )
static CErrorText<3500> errorText;
#else
static CErrorText<95000> errorText;
#endif
void BuildMinidumpComment( char const *pchSysErrorText, bool bRealCrash )
{
#if !defined(NO_STEAM)
/*
// Uncomment this code if you are testing max minidump comment length issues
// It allows you to asked for a dummy comment of a certain length
int nCommentLength = CommandLine()->ParmValue( "-commentlen", 0 );
if ( nCommentLength > 0 )
{
nCommentLength = MIN( nCommentLength, 128*1024 );
char *cbuf = new char[ nCommentLength + 1 ];
for ( int i = 0; i < nCommentLength; ++i )
{
cbuf[ i ] = (char)('0' + (i % 10));
}
cbuf[ nCommentLength ] = 0;
SteamAPI_SetMiniDumpComment( cbuf );
delete[] cbuf;
return;
}
*/
errorText.BuildComment( pchSysErrorText, bRealCrash );
#endif
}
#if defined( POSIX )
static void PosixPreMinidumpCallback( void *context )
{
BuildMinidumpComment( NULL, true );
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Attempt to initialize appid/steam.inf/minidump information. May only return partial information if called
// before Filesystem is ready.
//
// The desire is to be able to call this ASAP to init basic minidump and AppID info, then re-call later on when
// the filesystem is setup, so full version # information and such can be propagated to the minidump system.
// (Currently, SDK mods will generally only have partial information prior to filesystem init)
//-----------------------------------------------------------------------------
// steam.inf keys.
#define VERSION_KEY "PatchVersion="
#define PRODUCT_KEY "ProductName="
#define SERVER_VERSION_KEY "ServerVersion="
#define APPID_KEY "AppID="
#define SERVER_APPID_KEY "ServerAppID="
enum eSteamInfoInit
{
eSteamInfo_Uninitialized,
eSteamInfo_Partial,
eSteamInfo_Initialized
};
static eSteamInfoInit Sys_TryInitSteamInfo( void *pvAPI, SteamInfVersionInfo_t& VerInfo, const char *pchMod, const char *pchBaseDir, bool bDedicated )
{
static eSteamInfoInit initState = eSteamInfo_Uninitialized;
eSteamInfoInit previousInitState = initState;
//
//
// Initialize with some defaults.
VerInfo.ClientVersion = 0;
VerInfo.ServerVersion = 0;
V_strcpy_safe( VerInfo.szVersionString, "valve" );
V_strcpy_safe( VerInfo.szProductString, "1.0.1.0" );
VerInfo.AppID = k_uAppIdInvalid;
VerInfo.ServerAppID = k_uAppIdInvalid;
// Filesystem may or may not be up
CUtlBuffer infBuf;
bool bFoundInf = false;
if ( g_pFileSystem )
{
FileHandle_t fh;
fh = g_pFileSystem->Open( "steam.inf", "rb", "GAME" );
bFoundInf = fh && g_pFileSystem->ReadToBuffer( fh, infBuf );
}
if ( !bFoundInf )
{
// We may try to load the steam.inf BEFORE we turn on the filesystem, so use raw filesystem API's here.
char szFullPath[ MAX_PATH ] = { 0 };
char szModSteamInfPath[ MAX_PATH ] = { 0 };
V_ComposeFileName( pchMod, "steam.inf", szModSteamInfPath, sizeof( szModSteamInfPath ) );
V_MakeAbsolutePath( szFullPath, sizeof( szFullPath ), szModSteamInfPath, pchBaseDir );
// Try opening steam.inf
FILE *fp = fopen( szFullPath, "rb" );
if ( fp )
{
// Read steam.inf data.
fseek( fp, 0, SEEK_END );
size_t bufsize = ftell( fp );
fseek( fp, 0, SEEK_SET );
infBuf.EnsureCapacity( bufsize + 1 );
size_t iBytesRead = fread( infBuf.Base(), 1, bufsize, fp );
((char *)infBuf.Base())[iBytesRead] = 0;
infBuf.SeekPut( CUtlBuffer::SEEK_CURRENT, iBytesRead + 1 );
fclose( fp );
bFoundInf = ( iBytesRead == bufsize );
}
}
if ( bFoundInf )
{
const char *pbuf = (const char*)infBuf.Base();
while ( 1 )
{
pbuf = COM_Parse( pbuf );
if ( !pbuf || !com_token[ 0 ] )
break;
if ( !Q_strnicmp( com_token, VERSION_KEY, Q_strlen( VERSION_KEY ) ) )
{
V_strcpy_safe( VerInfo.szVersionString, com_token + Q_strlen( VERSION_KEY ) );
VerInfo.ClientVersion = atoi( VerInfo.szVersionString );
}
else if ( !Q_strnicmp( com_token, PRODUCT_KEY, Q_strlen( PRODUCT_KEY ) ) )
{
V_strcpy_safe( VerInfo.szProductString, com_token + Q_strlen( PRODUCT_KEY ) );
}
else if ( !Q_strnicmp( com_token, SERVER_VERSION_KEY, Q_strlen( SERVER_VERSION_KEY ) ) )
{
VerInfo.ServerVersion = atoi( com_token + Q_strlen( SERVER_VERSION_KEY ) );
}
else if ( !Q_strnicmp( com_token, APPID_KEY, Q_strlen( APPID_KEY ) ) )
{
VerInfo.AppID = atoi( com_token + Q_strlen( APPID_KEY ) );
}
else if ( !Q_strnicmp( com_token, SERVER_APPID_KEY, Q_strlen( SERVER_APPID_KEY ) ) )
{
VerInfo.ServerAppID = atoi( com_token + Q_strlen( SERVER_APPID_KEY ) );
}
}
// If we found a steam.inf we're as good as we're going to get, but don't tell callers we're fully initialized
// if it doesn't at least have an AppID
initState = ( VerInfo.AppID != k_uAppIdInvalid ) ? eSteamInfo_Initialized : eSteamInfo_Partial;
}
else if ( !bDedicated )
{
// Opening steam.inf failed - try to open gameinfo.txt and read in just SteamAppId from that.
// (gameinfo.txt lacks the dedicated server steamid, so we'll just have to live until filesystem init to setup
// breakpad there when we hit this case)
char szModGameinfoPath[ MAX_PATH ] = { 0 };
char szFullPath[ MAX_PATH ] = { 0 };
V_ComposeFileName( pchMod, "gameinfo.txt", szModGameinfoPath, sizeof( szModGameinfoPath ) );
V_MakeAbsolutePath( szFullPath, sizeof( szFullPath ), szModGameinfoPath, pchBaseDir );
// Try opening gameinfo.txt
FILE *fp = fopen( szFullPath, "rb" );
if( fp )
{
fseek( fp, 0, SEEK_END );
size_t bufsize = ftell( fp );
fseek( fp, 0, SEEK_SET );
char *buffer = ( char * )_alloca( bufsize + 1 );
size_t iBytesRead = fread( buffer, 1, bufsize, fp );
buffer[ iBytesRead ] = 0;
fclose( fp );
KeyValuesAD pkvGameInfo( "gameinfo" );
if ( pkvGameInfo->LoadFromBuffer( "gameinfo.txt", buffer ) )
{
VerInfo.AppID = (AppId_t)pkvGameInfo->GetInt( "FileSystem/SteamAppId", k_uAppIdInvalid );
}
}
initState = eSteamInfo_Partial;
}
// In partial state the ServerAppID might be unknown, but if we found the full steam.inf and it's not set, it shares AppID.
if ( initState == eSteamInfo_Initialized && VerInfo.ServerAppID == k_uAppIdInvalid )
VerInfo.ServerAppID = VerInfo.AppID;
#if !defined(_X360)
if ( VerInfo.AppID )
{
// steamclient.dll doesn't know about steam.inf files in mod folder,
// it accepts a steam_appid.txt in the root directory if the game is
// not started through Steam. So we create one there containing the
// current AppID
FILE *fh = fopen( "steam_appid.txt", "wb" );
if ( fh )
{
CFmtStrN< 128 > strAppID( "%u\n", VerInfo.AppID );
fwrite( strAppID.Get(), strAppID.Length() + 1, 1, fh );
fclose( fh );
}
}
#endif // !_X360
//
// Update minidump info if we have more information than before
//
#ifndef NO_STEAM
// If -nobreakpad was specified or we found metamod or sourcemod, don't register breakpad.
bool bUseBreakpad = !CommandLine()->FindParm( "-nobreakpad" ) && ( !bDedicated || !IsSourceModLoaded() );
AppId_t BreakpadAppId = bDedicated ? VerInfo.ServerAppID : VerInfo.AppID;
Assert( BreakpadAppId != k_uAppIdInvalid || initState < eSteamInfo_Initialized );
if ( BreakpadAppId != k_uAppIdInvalid && initState > previousInitState && bUseBreakpad )
{
void *pvMiniDumpContext = NULL;
PFNPreMinidumpCallback pfnPreMinidumpCallback = NULL;
bool bFullMemoryDump = !bDedicated && IsWindows() && CommandLine()->FindParm( "-full_memory_dumps" );
#if defined( POSIX )
// On Windows we're relying on the try/except to build the minidump comment. On Linux, we don't have that
// so we need to register the minidumpcallback handler here.
pvMiniDumpContext = pvAPI;
pfnPreMinidumpCallback = PosixPreMinidumpCallback;
#endif
CFmtStrN<128> pchVersion( "%d", build_number() );
Msg( "Using Breakpad minidump system. Version: %s AppID: %u\n", pchVersion.Get(), BreakpadAppId );
// We can filter various crash dumps differently in the Socorro backend code:
// Steam/min/web/crash_reporter/socorro/scripts/config/collectorconfig.py
SteamAPI_SetBreakpadAppID( BreakpadAppId );
SteamAPI_UseBreakpadCrashHandler( pchVersion, __DATE__, __TIME__, bFullMemoryDump, pvMiniDumpContext, pfnPreMinidumpCallback );
// Tell errorText class if this is dedicated server.
errorText.m_bIsDedicatedServer = bDedicated;
}
#endif // NO_STEAM
MinidumpUserStreamInfoSetHeader( "%sLaunching \"%s\"\n", ( bDedicated ? "DedicatedServerAPI " : "" ), CommandLine()->GetCmdLine() );
return initState;
}
#ifndef SWDS
//-----------------------------------------------------------------------------
//
// Main engine interface exposed to launcher
//
//-----------------------------------------------------------------------------
class CEngineAPI : public CTier3AppSystem< IEngineAPI >
{
typedef CTier3AppSystem< IEngineAPI > BaseClass;
public:
virtual bool Connect( CreateInterfaceFn factory );
virtual void Disconnect();
virtual void *QueryInterface( const char *pInterfaceName );
virtual InitReturnVal_t Init();
virtual void Shutdown();
// This function must be called before init
virtual void SetStartupInfo( StartupInfo_t &info );
virtual int Run( );
// Sets the engine to run in a particular editor window
virtual void SetEngineWindow( void *hWnd );
// Posts a console command
virtual void PostConsoleCommand( const char *pConsoleCommand );
// Are we running the simulation?
virtual bool IsRunningSimulation( ) const;
// Start/stop running the simulation
virtual void ActivateSimulation( bool bActive );
// Reset the map we're on
virtual void SetMap( const char *pMapName );
bool MainLoop();
int RunListenServer();
private:
// Hooks a particular mod up to the registry
void SetRegistryMod( const char *pModName );
// One-time setup, based on the initially selected mod
// FIXME: This should move into the launcher!
bool OnStartup( void *pInstance, const char *pStartupModName );
void OnShutdown();
// Initialization, shutdown of a mod.
bool ModInit( const char *pModName, const char *pGameDir );
void ModShutdown();
// Initializes, shuts down the registry
bool InitRegistry( const char *pModName );
void ShutdownRegistry();
// Handles there being an error setting up the video mode
InitReturnVal_t HandleSetModeError();
// Initializes, shuts down VR
bool InitVR();
void ShutdownVR();
// Purpose: Message pump when running stand-alone
void PumpMessages();
// Purpose: Message pump when running with the editor
void PumpMessagesEditMode( bool &bIdle, long &lIdleCount );
// Activate/deactivates edit mode shaders
void ActivateEditModeShaders( bool bActive );
private:
void *m_hEditorHWnd;
bool m_bRunningSimulation;
bool m_bSupportsVR;
StartupInfo_t m_StartupInfo;
};
//-----------------------------------------------------------------------------
// Singleton interface
//-----------------------------------------------------------------------------
static CEngineAPI s_EngineAPI;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineAPI, IEngineAPI, VENGINE_LAUNCHER_API_VERSION, s_EngineAPI );
//-----------------------------------------------------------------------------
// Connect, disconnect
//-----------------------------------------------------------------------------
bool CEngineAPI::Connect( CreateInterfaceFn factory )
{
// Store off the app system factory...
g_AppSystemFactory = factory;
if ( !BaseClass::Connect( factory ) )
return false;
g_pFileSystem = g_pFullFileSystem;
if ( !g_pFileSystem )
return false;
g_pFileSystem->SetWarningFunc( Warning );
if ( !Shader_Connect( true ) )
return false;
g_pPhysics = (IPhysics*)factory( VPHYSICS_INTERFACE_VERSION, NULL );
if ( !g_pStudioRender || !g_pDataCache || !g_pPhysics || !g_pMDLCache || !g_pMatSystemSurface || !g_pInputSystem /* || !g_pVideo */ )
{
Warning( "Engine wasn't able to acquire required interfaces!\n" );
return false;
}
if (!g_pStudioRender)
{
Sys_Error( "Unable to init studio render system version %s\n", STUDIO_RENDER_INTERFACE_VERSION );
return false;
}
g_pHammer = (IHammer*)factory( INTERFACEVERSION_HAMMER, NULL );
#if defined( USE_SDL )
g_pLauncherMgr = (ILauncherMgr *)factory( SDLMGR_INTERFACE_VERSION, NULL );
#endif
ConnectMDLCacheNotify();
return true;
}
void CEngineAPI::Disconnect()
{
DisconnectMDLCacheNotify();
#if !defined( SWDS )
TRACESHUTDOWN( Steam3Client().Shutdown() );
#endif
g_pHammer = NULL;
g_pPhysics = NULL;
Shader_Disconnect();
g_pFileSystem = NULL;
BaseClass::Disconnect();
g_AppSystemFactory = NULL;
}
//-----------------------------------------------------------------------------
// Query interface
//-----------------------------------------------------------------------------
void *CEngineAPI::QueryInterface( const char *pInterfaceName )
{
// Loading the engine DLL mounts *all* engine interfaces
CreateInterfaceFn factory = Sys_GetFactoryThis(); // This silly construction is necessary
return factory( pInterfaceName, NULL ); // to prevent the LTCG compiler from crashing.
}
//-----------------------------------------------------------------------------
// Sets startup info
//-----------------------------------------------------------------------------
void CEngineAPI::SetStartupInfo( StartupInfo_t &info )
{
// Setup and write out steam_appid.txt before we launch
bool bDedicated = false; // Dedicated comes through CDedicatedServerAPI
eSteamInfoInit steamInfo = Sys_TryInitSteamInfo( this, g_SteamInfIDVersionInfo, info.m_pInitialMod, info.m_pBaseDirectory, bDedicated );
g_bTextMode = info.m_bTextMode;
// Set up the engineparms_t which contains global information about the mod
host_parms.basedir = const_cast<char*>( info.m_pBaseDirectory );
// Copy off all the startup info
m_StartupInfo = info;
#if !defined( SWDS )
// turn on the Steam3 API early so we can query app data up front
TRACEINIT( Steam3Client().Activate(), Steam3Client().Shutdown() );
#endif
// Needs to be done prior to init material system config
TRACEINIT( COM_InitFilesystem( m_StartupInfo.m_pInitialMod ), COM_ShutdownFileSystem() );
if ( steamInfo != eSteamInfo_Initialized )
{
// Try again with filesystem available. This is commonly needed for SDK mods which need the filesystem to find
// their steam.inf, due to mounting SDK search paths.
steamInfo = Sys_TryInitSteamInfo( this, g_SteamInfIDVersionInfo, info.m_pInitialMod, info.m_pBaseDirectory, bDedicated );
Assert( steamInfo == eSteamInfo_Initialized );
if ( steamInfo != eSteamInfo_Initialized )
{
Warning( "Failed to find steam.inf or equivalent steam info. May not have proper information to connect to Steam.\n" );
}
}
m_bSupportsVR = false;
if ( IsPC() )
{
KeyValues *modinfo = new KeyValues("ModInfo");
if ( modinfo->LoadFromFile( g_pFileSystem, "gameinfo.txt" ) )
{
// Enable file tracking - client always does this in case it connects to a pure server.
// server only does this if sv_pure is set
// If it's not singleplayer_only
if ( V_stricmp( modinfo->GetString("type", "singleplayer_only"), "singleplayer_only") == 0 )
{
DevMsg( "Disabling whitelist file tracking in filesystem...\n" );
g_pFileSystem->EnableWhitelistFileTracking( false, false, false );
}
else
{
DevMsg( "Enabling whitelist file tracking in filesystem...\n" );
g_pFileSystem->EnableWhitelistFileTracking( true, false, false );
}
m_bSupportsVR = modinfo->GetInt( "supportsvr" ) > 0 && CommandLine()->CheckParm( "-vr" );
if ( m_bSupportsVR )
{
// This also has to happen before CreateGameWindow to know where to put
// the window and how big to make it
if ( InitVR() )
{
if ( Steam3Client().SteamUtils() )
{
if ( Steam3Client().SteamUtils()->IsSteamRunningInVR() && g_pSourceVR->IsHmdConnected() )
{
int nForceVRAdapterIndex = g_pSourceVR->GetVRModeAdapter();
materials->SetAdapter( nForceVRAdapterIndex, 0 );
g_pSourceVR->SetShouldForceVRMode();
}
}
}
}
}
modinfo->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
InitReturnVal_t CEngineAPI::Init()
{
if ( CommandLine()->FindParm( "-sv_benchmark" ) != 0 )
{
Plat_SetBenchmarkMode( true );
}
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
return nRetVal;
m_bRunningSimulation = false;
// Initialize the FPU control word
#if defined(WIN32) && !defined( SWDS ) && !defined( _X360 ) && !defined (__arm__)
_asm
{
fninit
}
#endif
SetupFPUControlWord();
// This creates the videomode singleton object, it doesn't depend on the registry
VideoMode_Create();
// Initialize the editor hwnd to render into
m_hEditorHWnd = NULL;
// One-time setup
// FIXME: OnStartup + OnShutdown should be removed + moved into the launcher
// or the launcher code should be merged into the engine into the code in OnStartup/OnShutdown
if ( !OnStartup( m_StartupInfo.m_pInstance, m_StartupInfo.m_pInitialMod ) )
{
return HandleSetModeError();
}
return INIT_OK;
}
void CEngineAPI::Shutdown()
{
VideoMode_Destroy();
BaseClass::Shutdown();
}
//-----------------------------------------------------------------------------
// Sets the engine to run in a particular editor window
//-----------------------------------------------------------------------------
void CEngineAPI::SetEngineWindow( void *hWnd )
{
if ( !InEditMode() )
return;
// Detach input from the previous editor window
game->InputDetachFromGameWindow();
m_hEditorHWnd = hWnd;
videomode->SetGameWindow( m_hEditorHWnd );
}
//-----------------------------------------------------------------------------
// Posts a console command
//-----------------------------------------------------------------------------
void CEngineAPI::PostConsoleCommand( const char *pCommand )
{
Cbuf_AddText( pCommand );
}
//-----------------------------------------------------------------------------
// Is the engine currently rinning?
//-----------------------------------------------------------------------------
bool CEngineAPI::IsRunningSimulation() const
{
return (eng->GetState() == IEngine::DLL_ACTIVE);
}
//-----------------------------------------------------------------------------
// Reset the map we're on
//-----------------------------------------------------------------------------
void CEngineAPI::SetMap( const char *pMapName )
{
// if ( !Q_stricmp( sv.mapname, pMapName ) )
// return;
char buf[MAX_PATH];
Q_snprintf( buf, MAX_PATH, "map %s", pMapName );
Cbuf_AddText( buf );
}
//-----------------------------------------------------------------------------
// Start/stop running the simulation
//-----------------------------------------------------------------------------
void CEngineAPI::ActivateSimulation( bool bActive )
{
// FIXME: Not sure what will happen in this case
if ( ( eng->GetState() != IEngine::DLL_ACTIVE ) &&
( eng->GetState() != IEngine::DLL_PAUSED ) )
{
return;
}
bool bCurrentlyActive = (eng->GetState() != IEngine::DLL_PAUSED);
if ( bActive == bCurrentlyActive )
return;
// FIXME: Should attachment/detachment be part of the state machine in IEngine?
if ( !bActive )
{
eng->SetNextState( IEngine::DLL_PAUSED );
// Detach input from the previous editor window
game->InputDetachFromGameWindow();
}
else
{
eng->SetNextState( IEngine::DLL_ACTIVE );
// Start accepting input from the new window
// FIXME: What if the attachment fails?
game->InputAttachToGameWindow();
}
}
static void MoveConsoleWindowToFront()
{
#ifdef _WIN32
// Move the window to the front.
HINSTANCE hInst = LoadLibrary( "kernel32.dll" );
if ( hInst )
{
typedef HWND (*GetConsoleWindowFn)();
GetConsoleWindowFn fn = (GetConsoleWindowFn)GetProcAddress( hInst, "GetConsoleWindow" );
if ( fn )
{
HWND hwnd = fn();
ShowWindow( hwnd, SW_SHOW );
UpdateWindow( hwnd );
SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
}
FreeLibrary( hInst );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Message pump when running stand-alone
//-----------------------------------------------------------------------------
void CEngineAPI::PumpMessages()
{
// This message pumping happens in SDL if SDL is enabled.
#if defined( PLATFORM_WINDOWS ) && !defined( USE_SDL )
MSG msg;
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
#endif
#if defined( USE_SDL )
g_pLauncherMgr->PumpWindowsMessageLoop();
#endif
// Get input from attached devices
g_pInputSystem->PollInputState();
if ( IsX360() )
{
// handle Xbox system messages
XBX_ProcessEvents();
}
// NOTE: Under some implementations of Win9x,
// dispatching messages can cause the FPU control word to change
if ( IsPC() )
{
SetupFPUControlWord();
}
game->DispatchAllStoredGameMessages();
if ( IsPC() )
{
static bool s_bFirstRun = true;
if ( s_bFirstRun )
{
s_bFirstRun = false;
MoveConsoleWindowToFront();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Message pump when running stand-alone
//-----------------------------------------------------------------------------
void CEngineAPI::PumpMessagesEditMode( bool &bIdle, long &lIdleCount )
{
if ( bIdle && !g_pHammer->HammerOnIdle( lIdleCount++ ) )
{
bIdle = false;
}
// Get input from attached devices
g_pInputSystem->PollInputState();
#ifdef WIN32
MSG msg;
while ( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
{
if ( msg.message == WM_QUIT )
{
eng->SetQuitting( IEngine::QUIT_TODESKTOP );
break;
}
if ( !g_pHammer->HammerPreTranslateMessage(&msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// Reset idle state after pumping idle message.
if ( g_pHammer->HammerIsIdleMessage(&msg) )
{
bIdle = true;
lIdleCount = 0;
}
}
#elif defined( USE_SDL )
Error( "Not supported" );
#else
#error
#endif
// NOTE: Under some implementations of Win9x,
// dispatching messages can cause the FPU control word to change
SetupFPUControlWord();
game->DispatchAllStoredGameMessages();
}
//-----------------------------------------------------------------------------
// Activate/deactivates edit mode shaders
//-----------------------------------------------------------------------------
void CEngineAPI::ActivateEditModeShaders( bool bActive )
{
if ( InEditMode() && ( g_pMaterialSystemConfig->bEditMode != bActive ) )
{
MaterialSystem_Config_t config = *g_pMaterialSystemConfig;
config.bEditMode = bActive;
OverrideMaterialSystemConfig( config );
}
}
#ifdef GPROFILER
static bool g_gprofiling = false;
CON_COMMAND( gprofilerstart, "Starts the gperftools profiler recording to the specified file." )
{
if ( g_gprofiling )
{
Msg( "Profiling is already started.\n" );
return;
}
char buffer[500];
const char* profname = buffer;
if ( args.ArgC() < 2 )
{
static const char *s_pszHomeDir = getenv("HOME");
if ( !s_pszHomeDir )
{
Msg( "Syntax: gprofile <outputfilename>\n" );
return;
}
// Use the current date and time to create a unique file name.time_t t = time(NULL);
time_t t = time(NULL);
struct tm tm = *localtime(&t);
V_sprintf_safe( buffer, "%s/valveprofile_%4d_%02d_%02d_%02d.%02d.%02d.prof", s_pszHomeDir,
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec );
// profname already points to buffer.
}
else
{
profname = args[1];
}
int result = ProfilerStart( profname );
if ( result )
{
Msg( "Profiling started successfully. Recording to %s. Stop profiling with gprofilerstop.\n", profname );
g_gprofiling = true;
}
else
{
Msg( "Profiling to %s failed to start - errno = %d.\n", profname, errno );
}
}
CON_COMMAND( gprofilerstop, "Stops the gperftools profiler." )
{
if ( g_gprofiling )
{
ProfilerStop();
Msg( "Stopped profiling.\n" );
g_gprofiling = false;
}
}
#endif
void StopGProfiler()
{
#ifdef GPROFILER
gprofilerstop( CCommand() );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Message pump
//-----------------------------------------------------------------------------
bool CEngineAPI::MainLoop()
{
bool bIdle = true;
long lIdleCount = 0;
// Main message pump
while ( true )
{
// Pump messages unless someone wants to quit
if ( eng->GetQuitting() != IEngine::QUIT_NOTQUITTING )
{
// We have to explicitly stop the profiler since otherwise symbol
// resolution doesn't work correctly.
StopGProfiler();
if ( eng->GetQuitting() != IEngine::QUIT_TODESKTOP )
return true;
return false;
}
// Pump the message loop
if ( !InEditMode() )
{
PumpMessages();
}
else
{
PumpMessagesEditMode( bIdle, lIdleCount );
}
// Run engine frame + hammer frame
if ( !InEditMode() || m_hEditorHWnd )
{
VCRSyncToken( "Frame" );
// Deactivate edit mode shaders
ActivateEditModeShaders( false );
eng->Frame();
// Reactivate edit mode shaders (in Edit mode only...)
ActivateEditModeShaders( true );
}
if ( InEditMode() )
{
g_pHammer->RunFrame();
}
}
return false;
}
//-----------------------------------------------------------------------------
// Initializes, shuts down the registry
//-----------------------------------------------------------------------------
bool CEngineAPI::InitRegistry( const char *pModName )
{
if ( IsPC() )
{
char szRegSubPath[MAX_PATH];
Q_snprintf( szRegSubPath, sizeof(szRegSubPath), "%s\\%s", "Source", pModName );
return registry->Init( szRegSubPath );
}
return true;
}
void CEngineAPI::ShutdownRegistry( )
{
if ( IsPC() )
{
registry->Shutdown( );
}
}
//-----------------------------------------------------------------------------
// Initializes, shuts down VR (via sourcevr.dll)
//-----------------------------------------------------------------------------
bool CEngineAPI::InitVR()
{
if ( m_bSupportsVR )
{
g_pSourceVR = (ISourceVirtualReality *)g_AppSystemFactory( SOURCE_VIRTUAL_REALITY_INTERFACE_VERSION, NULL );
if ( g_pSourceVR )
{
// make sure that the sourcevr DLL we loaded is secure. If not, don't
// let this client connect to secure servers.
if ( !Host_AllowLoadModule( "sourcevr" DLL_EXT_STRING, "EXECUTABLE_PATH", false ) )
{
Warning( "Preventing connections to secure servers because sourcevr.dll is not signed.\n" );
Host_DisallowSecureServers();
}
}
}
return true;
}
void CEngineAPI::ShutdownVR()
{
}
//-----------------------------------------------------------------------------
// One-time setup, based on the initially selected mod
// FIXME: This should move into the launcher!
//-----------------------------------------------------------------------------
bool CEngineAPI::OnStartup( void *pInstance, const char *pStartupModName )
{
// This fixes a bug on certain machines where the input will
// stop coming in for about 1 second when someone hits a key.
// (true means to disable priority boost)
#ifdef WIN32
if ( IsPC() )
{
SetThreadPriorityBoost( GetCurrentThread(), true );
}
#endif
// FIXME: Turn videomode + game into IAppSystems?
// Try to create the window
COM_TimestampedLog( "game->Init" );
// This has to happen before CreateGameWindow to set up the instance
// for use by the code that creates the window
if ( !game->Init( pInstance ) )
{
goto onStartupError;
}
// Try to create the window
COM_TimestampedLog( "videomode->Init" );
// This needs to be after Shader_Init and registry->Init
// This way mods can have different default video settings
if ( !videomode->Init( ) )
{
goto onStartupShutdownGame;
}
// We need to access the registry to get various settings (specifically,
// InitMaterialSystemConfig requires it).
if ( !InitRegistry( pStartupModName ) )
{
goto onStartupShutdownVideoMode;
}
materials->ModInit();
// Setup the material system config record, CreateGameWindow depends on it
// (when we're running stand-alone)
InitMaterialSystemConfig( InEditMode() );
#if defined( _X360 )
XBX_NotifyCreateListener( XNOTIFY_SYSTEM|XNOTIFY_LIVE|XNOTIFY_XMP );
#endif
ShutdownRegistry();
return true;
// Various error conditions
onStartupShutdownVideoMode:
videomode->Shutdown();
onStartupShutdownGame:
game->Shutdown();
onStartupError:
return false;
}
//-----------------------------------------------------------------------------
// One-time shutdown (shuts down stuff set up in OnStartup)
// FIXME: This should move into the launcher!
//-----------------------------------------------------------------------------
void CEngineAPI::OnShutdown()
{
if ( videomode )
{
videomode->Shutdown();
}
ShutdownVR();
// Shut down the game
game->Shutdown();
materials->ModShutdown();
TRACESHUTDOWN( COM_ShutdownFileSystem() );
}
static bool IsValveMod( const char *pModName )
{
// Figure out if we're running a Valve mod or not.
return ( Q_stricmp( GetCurrentMod(), "cstrike" ) == 0 ||
Q_stricmp( GetCurrentMod(), "dod" ) == 0 ||
Q_stricmp( GetCurrentMod(), "hl1mp" ) == 0 ||
Q_stricmp( GetCurrentMod(), "tf" ) == 0 ||
Q_stricmp( GetCurrentMod(), "tf_beta" ) == 0 ||
Q_stricmp( GetCurrentMod(), "hl2mp" ) == 0 );
}
//-----------------------------------------------------------------------------
// Initialization, shutdown of a mod.
//-----------------------------------------------------------------------------
bool CEngineAPI::ModInit( const char *pModName, const char *pGameDir )
{
// Set up the engineparms_t which contains global information about the mod
host_parms.mod = COM_StringCopy( GetModDirFromPath( pModName ) );
host_parms.game = COM_StringCopy( pGameDir );
// By default, restrict server commands in Valve games and don't restrict them in mods.
cl.m_bRestrictServerCommands = IsValveMod( host_parms.mod );
cl.m_bRestrictClientCommands = cl.m_bRestrictServerCommands;
// build the registry path we're going to use for this mod
InitRegistry( pModName );
// This sets up the game search path, depends on host_parms
TRACEINIT( MapReslistGenerator_Init(), MapReslistGenerator_Shutdown() );
#if !defined( _X360 )
TRACEINIT( DevShotGenerator_Init(), DevShotGenerator_Shutdown() );
#endif
// Slam cvars based on mod/config.cfg
Host_ReadPreStartupConfiguration();
bool bWindowed = g_pMaterialSystemConfig->Windowed();
if( g_pMaterialSystemConfig->m_nVRModeAdapter != -1 )
{
// at init time we never want to start up full screen
bWindowed = true;
}
// Create the game window now that we have a search path
// FIXME: Deal with initial window width + height better
if ( !videomode || !videomode->CreateGameWindow( g_pMaterialSystemConfig->m_VideoMode.m_Width, g_pMaterialSystemConfig->m_VideoMode.m_Height, bWindowed ) )
{
return false;
}
return true;
}
void CEngineAPI::ModShutdown()
{
COM_StringFree(host_parms.mod);
COM_StringFree(host_parms.game);
// Stop accepting input from the window
game->InputDetachFromGameWindow();
#if !defined( _X360 )
TRACESHUTDOWN( DevShotGenerator_Shutdown() );
#endif
TRACESHUTDOWN( MapReslistGenerator_Shutdown() );
ShutdownRegistry();
}
//-----------------------------------------------------------------------------
// Purpose: Handles there being an error setting up the video mode
// Output : Returns true on if the engine should restart, false if it should quit
//-----------------------------------------------------------------------------
InitReturnVal_t CEngineAPI::HandleSetModeError()
{
// show an error, see if the user wants to restart
if ( CommandLine()->FindParm( "-safe" ) )
{
Sys_MessageBox( "Failed to set video mode.\n\nThis game has a minimum requirement of DirectX 7.0 compatible hardware.\n", "Video mode error", false );
return INIT_FAILED;
}
if ( CommandLine()->FindParm( "-autoconfig" ) )
{
if ( Sys_MessageBox( "Failed to set video mode - falling back to safe mode settings.\n\nGame will now restart with the new video settings.", "Video - safe mode fallback", true ))
{
CommandLine()->AppendParm( "-safe", NULL );
return (InitReturnVal_t)INIT_RESTART;
}
return INIT_FAILED;
}
if ( Sys_MessageBox( "Failed to set video mode - resetting to defaults.\n\nGame will now restart with the new video settings.", "Video mode warning", true ) )
{
CommandLine()->AppendParm( "-autoconfig", NULL );
return (InitReturnVal_t)INIT_RESTART;
}
return INIT_FAILED;
}
//-----------------------------------------------------------------------------
// Purpose: Main loop for non-dedicated servers
//-----------------------------------------------------------------------------
int CEngineAPI::RunListenServer()
{
//
// NOTE: Systems set up here should depend on the mod
// Systems which are mod-independent should be set up in the launcher or Init()
//
// Innocent until proven guilty
int nRunResult = RUN_OK;
// Happens every time we start up and shut down a mod
if ( ModInit( m_StartupInfo.m_pInitialMod, m_StartupInfo.m_pInitialGame ) )
{
CModAppSystemGroup modAppSystemGroup( false, m_StartupInfo.m_pParentAppSystemGroup );
// Store off the app system factory...
g_AppSystemFactory = modAppSystemGroup.GetFactory();
nRunResult = modAppSystemGroup.Run();
g_AppSystemFactory = NULL;
// Shuts down the mod
ModShutdown();
// Disconnects from the editor window
videomode->SetGameWindow( NULL );
}
// Closes down things that were set up in OnStartup
// FIXME: OnStartup + OnShutdown should be removed + moved into the launcher
// or the launcher code should be merged into the engine into the code in OnStartup/OnShutdown
OnShutdown();
return nRunResult;
}
static void StaticRunListenServer( void *arg )
{
*(int *)arg = s_EngineAPI.RunListenServer();
}
// This function is set as the crash handler for unhandled exceptions and as the minidump
// handler for to be used by all of tier0's crash recording. This function
// adds a game-specific minidump comment and ensures that the SteamAPI function is
// used to save the minidump so that crashes are uploaded. SteamAPI has previously
// been configured to use breakpad by calling SteamAPI_UseBreakpadCrashHandler.
extern "C" void __cdecl WriteSteamMiniDumpWithComment( unsigned int uStructuredExceptionCode,
struct _EXCEPTION_POINTERS * pExceptionInfo,
const char *pszFilenameSuffix )
{
// TODO: dynamically set the minidump comment from contextual info about the crash (i.e current VPROF node)?
#if !defined( NO_STEAM )
if ( g_bUpdateMinidumpComment )
{
BuildMinidumpComment( NULL, true );
}
SteamAPI_WriteMiniDump( uStructuredExceptionCode, pExceptionInfo, build_number() );
// Clear DSound Buffers so the sound doesn't loop while the game shuts down
try
{
S_ClearBuffer();
}
catch ( ... )
{
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Main
//-----------------------------------------------------------------------------
int CEngineAPI::Run()
{
if ( CommandLine()->FindParm( "-insecure" ) || CommandLine()->FindParm( "-textmode" ) )
{
Host_DisallowSecureServers();
}
#ifdef _X360
return RunListenServer(); // don't handle exceptions on 360 (because if we do then minidumps won't work at all)
#elif defined ( _WIN32 )
// Ensure that we crash when we do something naughty in a callback
// such as a window proc. Otherwise on a 64-bit OS the crashes will be
// silently swallowed.
EnableCrashingOnCrashes();
// Set the default minidump handling function. This is necessary so that Steam
// will upload crashes, with comments.
SetMiniDumpFunction( WriteSteamMiniDumpWithComment );
// Catch unhandled crashes. A normal __try/__except block will not work across
// the kernel callback boundary, but this does. To be clear, __try/__except
// and try/catch will usually not catch exceptions in a WindowProc or other
// callback that is called from kernel mode because 64-bit Windows cannot handle
// throwing exceptions across that boundary. See this article for details:
// http://blog.paulbetts.org/index.php/2010/07/20/the-case-of-the-disappearing-onload-exception-user-mode-callback-exceptions-in-x64/
// Note that the unhandled exception function is not called when running
// under a debugger, but that's fine because in that case we don't care about
// recording minidumps.
// The try/catch block still makes sense because it is a more reliable way
// of catching exceptions that aren't in callbacks.
// The unhandled exception filter will also catch crashes in threads that
// don't have a try/catch or __try/__except block.
bool noMinidumps = CommandLine()->FindParm( "-nominidumps");
if ( !noMinidumps )
MinidumpSetUnhandledExceptionFunction( WriteSteamMiniDumpWithComment );
if ( !Plat_IsInDebugSession() && !noMinidumps )
{
int nRetVal = RUN_OK;
CatchAndWriteMiniDumpForVoidPtrFn( StaticRunListenServer, &nRetVal, true );
return nRetVal;
}
else
{
return RunListenServer();
}
#else
return RunListenServer();
#endif
}
#endif // SWDS
bool g_bUsingLegacyAppSystems = false;
bool CModAppSystemGroup::AddLegacySystems()
{
g_bUsingLegacyAppSystems = true;
AppSystemInfo_t appSystems[] =
{
{ "soundemittersystem", SOUNDEMITTERSYSTEM_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
if ( !AddSystems( appSystems ) )
return false;
#if !defined( DEDICATED )
// if ( CommandLine()->FindParm( "-tools" ) )
{
AppModule_t toolFrameworkModule = LoadModule( "engine" DLL_EXT_STRING );
if ( !AddSystem( toolFrameworkModule, VTOOLFRAMEWORK_INTERFACE_VERSION ) )
return false;
}
#endif
return true;
}
//-----------------------------------------------------------------------------
// Instantiate all main libraries
//-----------------------------------------------------------------------------
bool CModAppSystemGroup::Create()
{
#ifndef SWDS
if ( !IsServerOnly() )
{
if ( !ClientDLL_Load() )
return false;
}
#endif
if ( !ServerDLL_Load( IsServerOnly() ) )
return false;
IClientDLLSharedAppSystems *clientSharedSystems = 0;
#ifndef SWDS
if ( !IsServerOnly() )
{
clientSharedSystems = ( IClientDLLSharedAppSystems * )g_ClientFactory( CLIENT_DLL_SHARED_APPSYSTEMS, NULL );
if ( !clientSharedSystems )
return AddLegacySystems();
}
#endif
IServerDLLSharedAppSystems *serverSharedSystems = ( IServerDLLSharedAppSystems * )g_ServerFactory( SERVER_DLL_SHARED_APPSYSTEMS, NULL );
if ( !serverSharedSystems )
{
Assert( !"Expected both game and client .dlls to have or not have shared app systems interfaces!!!" );
return AddLegacySystems();
}
// Load game and client .dlls and build list then
CUtlVector< AppSystemInfo_t > systems;
int i;
int serverCount = serverSharedSystems->Count();
for ( i = 0 ; i < serverCount; ++i )
{
const char *dllName = serverSharedSystems->GetDllName( i );
const char *interfaceName = serverSharedSystems->GetInterfaceName( i );
AppSystemInfo_t info;
info.m_pModuleName = dllName;
info.m_pInterfaceName = interfaceName;
systems.AddToTail( info );
}
if ( !IsServerOnly() )
{
int clientCount = clientSharedSystems->Count();
for ( i = 0 ; i < clientCount; ++i )
{
const char *dllName = clientSharedSystems->GetDllName( i );
const char *interfaceName = clientSharedSystems->GetInterfaceName( i );
if ( ModuleAlreadyInList( systems, dllName, interfaceName ) )
continue;
AppSystemInfo_t info;
info.m_pModuleName = dllName;
info.m_pInterfaceName = interfaceName;
systems.AddToTail( info );
}
}
AppSystemInfo_t info;
info.m_pModuleName = "";
info.m_pInterfaceName = "";
systems.AddToTail( info );
if ( !AddSystems( systems.Base() ) )
return false;
#if !defined( DEDICATED )
// if ( CommandLine()->FindParm( "-tools" ) )
{
AppModule_t toolFrameworkModule = LoadModule( "engine" DLL_EXT_STRING );
if ( !AddSystem( toolFrameworkModule, VTOOLFRAMEWORK_INTERFACE_VERSION ) )
return false;
}
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Fixme, we might need to verify if the interface names differ for the client versus the server
// Input : list -
// *moduleName -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CModAppSystemGroup::ModuleAlreadyInList( CUtlVector< AppSystemInfo_t >& list, const char *moduleName, const char *interfaceName )
{
for ( int i = 0; i < list.Count(); ++i )
{
if ( !Q_stricmp( list[ i ].m_pModuleName, moduleName ) )
{
if ( Q_stricmp( list[ i ].m_pInterfaceName, interfaceName ) )
{
Error( "Game and client .dlls requesting different versions '%s' vs. '%s' from '%s'\n",
list[ i ].m_pInterfaceName, interfaceName, moduleName );
}
return true;
}
}
return false;
}
bool CModAppSystemGroup::PreInit()
{
return true;
}
void SV_ShutdownGameDLL();
int CModAppSystemGroup::Main()
{
int nRunResult = RUN_OK;
if ( IsServerOnly() )
{
// Start up the game engine
if ( eng->Load( true, host_parms.basedir ) )
{
// If we're using STEAM, pass the map cycle list as resource hints...
// Dedicated server drives frame loop manually
dedicated->RunServer();
SV_ShutdownGameDLL();
}
}
else
{
eng->SetQuitting( IEngine::QUIT_NOTQUITTING );
COM_TimestampedLog( "eng->Load" );
// Start up the game engine
static const char engineLoadMessage[] = "Calling CEngine::Load";
int64 nStartTime = ETWBegin( engineLoadMessage );
if ( eng->Load( false, host_parms.basedir ) )
{
#if !defined(SWDS)
ETWEnd( engineLoadMessage, nStartTime );
toolframework->ServerInit( g_ServerFactory );
if ( s_EngineAPI.MainLoop() )
{
nRunResult = RUN_RESTART;
}
// unload systems
eng->Unload();
toolframework->ServerShutdown();
#endif
SV_ShutdownGameDLL();
}
}
return nRunResult;
}
void CModAppSystemGroup::PostShutdown()
{
}
void CModAppSystemGroup::Destroy()
{
// unload game and client .dlls
ServerDLL_Unload();
#ifndef SWDS
if ( !IsServerOnly() )
{
ClientDLL_Unload();
}
#endif
}
//-----------------------------------------------------------------------------
//
// Purpose: Expose engine interface to launcher for dedicated servers
//
//-----------------------------------------------------------------------------
class CDedicatedServerAPI : public CTier3AppSystem< IDedicatedServerAPI >
{
typedef CTier3AppSystem< IDedicatedServerAPI > BaseClass;
public:
CDedicatedServerAPI() :
m_pDedicatedServer( 0 )
{
}
virtual bool Connect( CreateInterfaceFn factory );
virtual void Disconnect();
virtual void *QueryInterface( const char *pInterfaceName );
virtual bool ModInit( ModInfo_t &info );
virtual void ModShutdown( void );
virtual bool RunFrame( void );
virtual void AddConsoleText( char *text );
virtual void UpdateStatus(float *fps, int *nActive, int *nMaxPlayers, char *pszMap, int maxlen );
virtual void UpdateHostname(char *pszHostname, int maxlen);
CModAppSystemGroup *m_pDedicatedServer;
};
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
EXPOSE_SINGLE_INTERFACE( CDedicatedServerAPI, IDedicatedServerAPI, VENGINE_HLDS_API_VERSION );
#define LONG_TICK_TIME 0.12f // about 8/66ths of a second
#define MIN_TIME_BETWEEN_DUMPED_TICKS 5.0f;
#define MAX_DUMPS_PER_LONG_TICK 10
void Sys_Sleep ( int msec );
bool g_bLongTickWatcherThreadEnabled = false;
bool g_bQuitLongTickWatcherThread = false;
int g_bTotalDumps = 0;
DWORD __stdcall LongTickWatcherThread( void *voidPtr )
{
int nLastTick = 0;
double flWarnTickTime = 0.0f;
double flNextPossibleDumpTime = Plat_FloatTime() + MIN_TIME_BETWEEN_DUMPED_TICKS;
int nNumDumpsThisTick = 0;
while ( eng->GetQuitting() == IEngine::QUIT_NOTQUITTING && !g_bQuitLongTickWatcherThread )
{
if ( sv.m_State == ss_active && sv.m_bSimulatingTicks )
{
int curTick = sv.m_nTickCount;
double curTime = Plat_FloatTime();
if ( nLastTick > 0 && nLastTick == curTick )
{
if ( curTime > flNextPossibleDumpTime && curTime > flWarnTickTime && nNumDumpsThisTick < MAX_DUMPS_PER_LONG_TICK )
{
nNumDumpsThisTick++;
g_bTotalDumps++;
Warning( "Long tick after tick %i. Writing minidump #%i (%i total).\n", nLastTick, nNumDumpsThisTick, g_bTotalDumps );
if ( nNumDumpsThisTick == MAX_DUMPS_PER_LONG_TICK )
{
Msg( "Not writing any more minidumps for this tick.\n" );
}
// If you're debugging a minidump and you ended up here, you probably want to switch to the main thread.
WriteMiniDump( "longtick" );
}
}
if ( nLastTick != curTick )
{
if ( nNumDumpsThisTick )
{
Msg( "Long tick lasted about %.1f seconds.\n", curTime - (flWarnTickTime - LONG_TICK_TIME) );
nNumDumpsThisTick = 0;
flNextPossibleDumpTime = curTime + MIN_TIME_BETWEEN_DUMPED_TICKS;
}
nLastTick = curTick;
flWarnTickTime = curTime + LONG_TICK_TIME;
}
}
else
{
nLastTick = 0;
}
if ( nNumDumpsThisTick )
{
// We'll write the next minidump 0.06 seconds from now.
Sys_Sleep( 60 );
}
else
{
// Check tick progress every 1/100th of a second.
Sys_Sleep( 10 );
}
}
g_bLongTickWatcherThreadEnabled = false;
g_bQuitLongTickWatcherThread = false;
return 0;
}
bool EnableLongTickWatcher()
{
bool bRet = false;
if ( !g_bLongTickWatcherThreadEnabled )
{
g_bQuitLongTickWatcherThread = false;
g_bLongTickWatcherThreadEnabled = true;
DWORD nThreadID;
VCRHook_CreateThread(NULL, 0,
#ifdef POSIX
(void*)
#endif
LongTickWatcherThread, NULL, 0, (uintp *)&nThreadID );
bRet = true;
}
else if ( g_bQuitLongTickWatcherThread )
{
Msg( "Cannot create a new long tick watcher while waiting for an old one to terminate.\n" );
}
else
{
Msg( "The long tick watcher thread is already running.\n" );
}
return bRet;
}
//-----------------------------------------------------------------------------
// Dedicated server entrypoint
//-----------------------------------------------------------------------------
bool CDedicatedServerAPI::Connect( CreateInterfaceFn factory )
{
if ( CommandLine()->FindParm( "-sv_benchmark" ) != 0 )
{
Plat_SetBenchmarkMode( true );
}
if ( CommandLine()->FindParm( "-dumplongticks" ) )
{
Msg( "-dumplongticks found on command line. Activating long tick watcher thread.\n" );
EnableLongTickWatcher();
}
// Store off the app system factory...
g_AppSystemFactory = factory;
if ( !BaseClass::Connect( factory ) )
return false;
dedicated = ( IDedicatedExports * )factory( VENGINE_DEDICATEDEXPORTS_API_VERSION, NULL );
if ( !dedicated )
return false;
g_pFileSystem = g_pFullFileSystem;
g_pFileSystem->SetWarningFunc( Warning );
if ( !Shader_Connect( false ) )
return false;
if ( !g_pStudioRender )
{
Sys_Error( "Unable to init studio render system version %s\n", STUDIO_RENDER_INTERFACE_VERSION );
return false;
}
g_pPhysics = (IPhysics*)factory( VPHYSICS_INTERFACE_VERSION, NULL );
if ( !g_pDataCache || !g_pPhysics || !g_pMDLCache )
{
Warning( "Engine wasn't able to acquire required interfaces!\n" );
return false;
}
ConnectMDLCacheNotify();
return true;
}
void CDedicatedServerAPI::Disconnect()
{
DisconnectMDLCacheNotify();
g_pPhysics = NULL;
Shader_Disconnect();
g_pFileSystem = NULL;
ConVar_Unregister();
dedicated = NULL;
BaseClass::Disconnect();
g_AppSystemFactory = NULL;
}
//-----------------------------------------------------------------------------
// Query interface
//-----------------------------------------------------------------------------
void *CDedicatedServerAPI::QueryInterface( const char *pInterfaceName )
{
// Loading the engine DLL mounts *all* engine interfaces
CreateInterfaceFn factory = Sys_GetFactoryThis(); // This silly construction is necessary
return factory( pInterfaceName, NULL ); // to prevent the LTCG compiler from crashing.
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : type - 0 == normal, 1 == dedicated server
// *instance -
// *basedir -
// *cmdline -
// launcherFactory -
//-----------------------------------------------------------------------------
bool CDedicatedServerAPI::ModInit( ModInfo_t &info )
{
// Setup and write out steam_appid.txt before we launch
bool bDedicated = true;
eSteamInfoInit steamInfo = Sys_TryInitSteamInfo( this, g_SteamInfIDVersionInfo, info.m_pInitialMod, info.m_pBaseDirectory, bDedicated );
eng->SetQuitting( IEngine::QUIT_NOTQUITTING );
// Set up the engineparms_t which contains global information about the mod
host_parms.basedir = const_cast<char*>(info.m_pBaseDirectory);
host_parms.mod = const_cast<char*>(GetModDirFromPath(info.m_pInitialMod));
host_parms.game = const_cast<char*>(info.m_pInitialGame);
g_bTextMode = info.m_bTextMode;
TRACEINIT( COM_InitFilesystem( info.m_pInitialMod ), COM_ShutdownFileSystem() );
if ( steamInfo != eSteamInfo_Initialized )
{
// Try again with filesystem available. This is commonly needed for SDK mods which need the filesystem to find
// their steam.inf, due to mounting SDK search paths.
steamInfo = Sys_TryInitSteamInfo( this, g_SteamInfIDVersionInfo, info.m_pInitialMod, info.m_pBaseDirectory, bDedicated );
Assert( steamInfo == eSteamInfo_Initialized );
if ( steamInfo != eSteamInfo_Initialized )
{
Warning( "Failed to find steam.inf or equivalent steam info. May not have proper information to connect to Steam.\n" );
}
}
// set this up as early as possible, if the server isn't going to run pure, stop CRCing bits as we load them
// this happens even before the ConCommand's are processed, but we need to be sure to either CRC every file
// that is loaded, or not bother doing any
// Note that this mirrors g_sv_pure_mode from sv_main.cpp
int pure_mode = 1; // default to on, +sv_pure 0 or -sv_pure 0 will turn it off
if ( CommandLine()->CheckParm("+sv_pure") )
pure_mode = CommandLine()->ParmValue( "+sv_pure", 1 );
else if ( CommandLine()->CheckParm("-sv_pure") )
pure_mode = CommandLine()->ParmValue( "-sv_pure", 1 );
if ( pure_mode )
g_pFullFileSystem->EnableWhitelistFileTracking( true, true, CommandLine()->FindParm( "-sv_pure_verify_hashes" ) ? true : false );
else
g_pFullFileSystem->EnableWhitelistFileTracking( false, false, false );
materials->ModInit();
// Setup the material system config record, CreateGameWindow depends on it
// (when we're running stand-alone)
#ifndef SWDS
InitMaterialSystemConfig( true ); // !!should this be called standalone or not?
#endif
// Initialize general game stuff and create the main window
if ( game->Init( NULL ) )
{
m_pDedicatedServer = new CModAppSystemGroup( true, info.m_pParentAppSystemGroup );
// Store off the app system factory...
g_AppSystemFactory = m_pDedicatedServer->GetFactory();
m_pDedicatedServer->Run();
return true;
}
return false;
}
void CDedicatedServerAPI::ModShutdown( void )
{
if ( m_pDedicatedServer )
{
delete m_pDedicatedServer;
m_pDedicatedServer = NULL;
}
g_AppSystemFactory = NULL;
// Unload GL, Sound, etc.
eng->Unload();
// Shut down memory, etc.
game->Shutdown();
materials->ModShutdown();
TRACESHUTDOWN( COM_ShutdownFileSystem() );
}
bool CDedicatedServerAPI::RunFrame( void )
{
// Bail if someone wants to quit.
if ( eng->GetQuitting() != IEngine::QUIT_NOTQUITTING )
{
return false;
}
// Run engine frame
eng->Frame();
return true;
}
void CDedicatedServerAPI::AddConsoleText( char *text )
{
Cbuf_AddText( text );
}
void CDedicatedServerAPI::UpdateStatus(float *fps, int *nActive, int *nMaxPlayers, char *pszMap, int maxlen )
{
Host_GetHostInfo( fps, nActive, nMaxPlayers, pszMap, maxlen );
}
void CDedicatedServerAPI::UpdateHostname(char *pszHostname, int maxlen)
{
if ( pszHostname && ( maxlen > 0 ) )
{
Q_strncpy( pszHostname, sv.GetName(), maxlen );
}
}
#ifndef SWDS
class CGameUIFuncs : public IGameUIFuncs
{
public:
bool IsKeyDown( const char *keyname, bool& isdown )
{
isdown = false;
if ( !g_ClientDLL )
return false;
return g_ClientDLL->IN_IsKeyDown( keyname, isdown );
}
const char *GetBindingForButtonCode( ButtonCode_t code )
{
return ::Key_BindingForKey( code );
}
virtual ButtonCode_t GetButtonCodeForBind( const char *bind )
{
const char *pKeyName = Key_NameForBinding( bind );
if ( !pKeyName )
return KEY_NONE;
return g_pInputSystem->StringToButtonCode( pKeyName ) ;
}
void GetVideoModes( struct vmode_s **ppListStart, int *pCount )
{
if ( videomode )
{
*pCount = videomode->GetModeCount();
*ppListStart = videomode->GetMode( 0 );
}
else
{
*pCount = 0;
*ppListStart = NULL;
}
}
void GetDesktopResolution( int &width, int &height )
{
int refreshrate;
game->GetDesktopInfo( width, height, refreshrate );
}
virtual void SetFriendsID( uint friendsID, const char *friendsName )
{
cl.SetFriendsID( friendsID, friendsName );
}
bool IsConnectedToVACSecureServer()
{
if ( cl.IsConnected() )
return Steam3Client().BGSSecure();
return false;
}
};
EXPOSE_SINGLE_INTERFACE( CGameUIFuncs, IGameUIFuncs, VENGINE_GAMEUIFUNCS_VERSION );
#endif
CON_COMMAND( dumplongticks, "Enables generating minidumps on long ticks." )
{
int enable = atoi( args[1] );
if ( args.ArgC() == 1 || enable )
{
if ( EnableLongTickWatcher() )
{
Msg( "Long tick watcher thread created. Use \"dumplongticks 0\" to disable.\n" );
}
}
else
{
// disable watcher thread if enabled
if ( g_bLongTickWatcherThreadEnabled && !g_bQuitLongTickWatcherThread )
{
Msg( "Disabling the long tick watcher.\n" );
g_bQuitLongTickWatcherThread = true;
}
else
{
Msg( "The long tick watcher is already disabled.\n" );
}
}
}