mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 14:16:50 +00:00
2573 lines
71 KiB
C++
2573 lines
71 KiB
C++
//========= 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" );
|
|
}
|
|
}
|
|
}
|
|
|