source-engine/launcher/launcher.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// Defines the entry point for the application.
//
//===========================================================================//

#if defined( _WIN32 ) && !defined( _X360 )
#include <windows.h>
#include "shlwapi.h" // registry stuff
#include <direct.h>
#elif defined ( LINUX ) || defined( OSX )
	#define O_EXLOCK 0
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <locale.h>
#elif defined ( _X360 )
#else
#error
#endif
#include "appframework/ilaunchermgr.h"
#include <stdio.h>
#include "tier0/icommandline.h"
#include "engine_launcher_api.h"
#include "tier0/vcrmode.h"
#include "ifilesystem.h"
#include "tier1/interface.h"
#include "tier0/dbg.h"
#include "iregistry.h"
#include "appframework/IAppSystem.h"
#include "appframework/AppFramework.h"
#include <vgui/VGUI.h>
#include <vgui/ISurface.h>
#include "tier0/platform.h"
#include "tier0/memalloc.h"
#include "filesystem.h"
#include "tier1/utlrbtree.h"
#include "materialsystem/imaterialsystem.h"
#include "istudiorender.h"
#include "vgui/IVGui.h"
#include "IHammer.h"
#include "datacache/idatacache.h"
#include "datacache/imdlcache.h"
#include "vphysics_interface.h"
#include "filesystem_init.h"
#include "vstdlib/iprocessutils.h"
#include "video/ivideoservices.h"
#include "tier1/tier1.h"
#include "tier2/tier2.h"
#include "tier3/tier3.h"
#include "p4lib/ip4.h"
#include "inputsystem/iinputsystem.h"
#include "filesystem/IQueuedLoader.h"
#include "reslistgenerator.h"
#include "tier1/fmtstr.h"
#include "sourcevr/isourcevirtualreality.h"

#define VERSION_SAFE_STEAM_API_INTERFACES
#include "steam/steam_api.h"

#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#include "xbox/xbox_console.h"
#include "xbox/xbox_launch.h"
#endif

#if defined( USE_SDL )
#include "SDL.h"

#if !defined( _WIN32 )
#define MB_OK 			0x00000001
#define MB_SYSTEMMODAL	0x00000002
#define MB_ICONERROR	0x00000004
int MessageBox( HWND hWnd, const char *message, const char *header, unsigned uType );
#endif // _WIN32

#endif // USE_SDL

#if defined( POSIX )
#define RELAUNCH_FILE "/tmp/hl2_relaunch"
#endif

#if defined ( ANDROID )
#include <android/log.h>
#include "jni.h"
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#define DEFAULT_HL2_GAMEDIR	"hl2"

#if defined( USE_SDL )
extern void* CreateSDLMgr();
#endif

//-----------------------------------------------------------------------------
// Modules...
//-----------------------------------------------------------------------------
static IEngineAPI *g_pEngineAPI;
static IHammer *g_pHammer;

bool g_bTextMode = false;

static char g_szBasedir[MAX_PATH];
static char g_szGamedir[MAX_PATH];

// copied from sys.h
struct FileAssociationInfo
{
	char const  *extension;
	char const  *command_to_issue;
};

static FileAssociationInfo g_FileAssociations[] =
{
	{ ".dem", "playdemo" },
	{ ".sav", "load" },
	{ ".bsp", "map" },
};

#ifdef _WIN32
#pragma warning(disable:4073)
#pragma init_seg(lib)
#endif

class CLeakDump
{
public:
	CLeakDump()
	 :	m_bCheckLeaks( false )
	{
	}

	~CLeakDump()
	{
		if ( m_bCheckLeaks )
		{
			MemAlloc_DumpStats();
		}
	}

	bool m_bCheckLeaks;
} g_LeakDump;

//-----------------------------------------------------------------------------
// Spew function!
//-----------------------------------------------------------------------------
SpewRetval_t LauncherDefaultSpewFunc( SpewType_t spewType, char const *pMsg )
{
#ifndef _CERT
#ifdef WIN32
	OutputDebugStringA( pMsg );
#else
	fprintf( stderr, "%s", pMsg );
#endif
	
	switch( spewType )
	{
	case SPEW_MESSAGE:
	case SPEW_LOG:
		return SPEW_CONTINUE;

	case SPEW_WARNING:
		if ( !stricmp( GetSpewOutputGroup(), "init" ) )
		{
#if defined( WIN32 ) || defined( USE_SDL )
			::MessageBox( NULL, pMsg, "Warning!", MB_OK | MB_SYSTEMMODAL | MB_ICONERROR );
#endif
		}
		return SPEW_CONTINUE;

	case SPEW_ASSERT:
		if ( !ShouldUseNewAssertDialog() )
		{
#if defined( WIN32 ) || defined( USE_SDL )
			::MessageBox( NULL, pMsg, "Assert!", MB_OK | MB_SYSTEMMODAL | MB_ICONERROR );
#endif
		}
		return SPEW_DEBUGGER;
	
	case SPEW_ERROR:
	default:
#if defined( WIN32 ) || defined( USE_SDL )
		::MessageBox( NULL, pMsg, "Error!", MB_OK | MB_SYSTEMMODAL | MB_ICONERROR );
#endif
		_exit( 1 );
	}
#else
	if ( spewType != SPEW_ERROR)
		return SPEW_CONTINUE;
	_exit( 1 );
#endif
}


//-----------------------------------------------------------------------------
// Implementation of VCRHelpers.
//-----------------------------------------------------------------------------
class CVCRHelpers : public IVCRHelpers
{
public:
	virtual void ErrorMessage( const char *pMsg )
	{
#if defined( WIN32 ) || defined( LINUX )
		NOVCR( ::MessageBox( NULL, pMsg, "VCR Error", MB_OK ) );
#endif
	}

	virtual void* GetMainWindow()
	{
		return NULL;
	}
};

static CVCRHelpers g_VCRHelpers;

//-----------------------------------------------------------------------------
// Purpose: Return the game directory
// Output : char
//-----------------------------------------------------------------------------
char *GetGameDirectory( void )
{
	return g_szGamedir;
}

void SetGameDirectory( const char *game )
{
	Q_strncpy( g_szGamedir, game, sizeof(g_szGamedir) );
}

//-----------------------------------------------------------------------------
// Gets the executable name
//-----------------------------------------------------------------------------
bool GetExecutableName( char *out, int outSize )
{
#ifdef WIN32
	if ( !::GetModuleFileName( ( HINSTANCE )GetModuleHandle( NULL ), out, outSize ) )
	{
		return false;
	}
	return true;
#else
	return false;
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Return the base directory
// Output : char
//-----------------------------------------------------------------------------
char *GetBaseDirectory( void )
{
#ifdef ANDROID
	return getenv("VALVE_GAME_PATH");
#else
	return g_szBasedir;
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Determine the directory where this .exe is running from
//-----------------------------------------------------------------------------
void UTIL_ComputeBaseDir()
{
	g_szBasedir[0] = 0;

	if ( IsX360() )
	{
		char const *pBaseDir = CommandLine()->ParmValue( "-basedir" );
		if ( pBaseDir )
		{
			strcpy( g_szBasedir, pBaseDir );
		}
	}

	if ( !g_szBasedir[0] && GetExecutableName( g_szBasedir, sizeof( g_szBasedir ) ) )
	{
		char *pBuffer = strrchr( g_szBasedir, '\\' );
		if ( *pBuffer )
		{
			*(pBuffer+1) = '\0';
		}

		int j = strlen( g_szBasedir );
		if (j > 0)
		{
			if ( ( g_szBasedir[j-1] == '\\' ) || 
				 ( g_szBasedir[j-1] == '/' ) )
			{
				g_szBasedir[j-1] = 0;
			}
		}
	}

	if ( IsPC() )
	{
		char const *pOverrideDir = CommandLine()->CheckParm( "-basedir" );
		if ( pOverrideDir )
		{
			strcpy( g_szBasedir, pOverrideDir );
		}
	}

#ifdef WIN32
	Q_strlower( g_szBasedir );
#endif
	Q_FixSlashes( g_szBasedir );
}

#ifdef WIN32
BOOL WINAPI MyHandlerRoutine( DWORD dwCtrlType )
{
#if !defined( _X360 )
	TerminateProcess( GetCurrentProcess(), 2 );
#endif
	return TRUE;
}
#endif

void InitTextMode()
{
#ifdef WIN32
#if !defined( _X360 )
	AllocConsole();

	SetConsoleCtrlHandler( MyHandlerRoutine, TRUE );

	freopen( "CONIN$", "rb", stdin );		// reopen stdin handle as console window input
	freopen( "CONOUT$", "wb", stdout );		// reopen stout handle as console window output
	freopen( "CONOUT$", "wb", stderr );		// reopen stderr handle as console window output
#else
	XBX_Error( "%s %s: Not Supported", __FILE__, __LINE__ );
#endif
#endif
}

void SortResList( char const *pchFileName, char const *pchSearchPath );

#define ALL_RESLIST_FILE	"all.lst"
#define ENGINE_RESLIST_FILE  "engine.lst"

// create file to dump out to
class CLogAllFiles
{
public:
	CLogAllFiles();
	void Init();
	void Shutdown();
	void LogFile( const char *fullPathFileName, const char *options );

private:
	static void LogAllFilesFunc( const char *fullPathFileName, const char *options );
	void LogToAllReslist( char const *line );

	bool		m_bActive;
	char		m_szCurrentDir[_MAX_PATH];

	// persistent across restarts
	CUtlRBTree< CUtlString, int > m_Logged;
	CUtlString	m_sResListDir;
	CUtlString	m_sFullGamePath;
};

static CLogAllFiles g_LogFiles;

static bool AllLogLessFunc( CUtlString const &pLHS, CUtlString const &pRHS )
{
	return CaselessStringLessThan( pLHS.Get(), pRHS.Get() );
}

CLogAllFiles::CLogAllFiles() :
	m_bActive( false ),
	m_Logged( 0, 0, AllLogLessFunc )
{
	MEM_ALLOC_CREDIT();
	m_sResListDir = "reslists";
}

void CLogAllFiles::Init()
{
	if ( IsX360() )
	{
		return;
	}

	// Can't do this in edit mode
	if ( CommandLine()->CheckParm( "-edit" ) )
	{
		return;
	}

	if ( !CommandLine()->CheckParm( "-makereslists" ) )
	{
		return;
	}

	m_bActive = true;

	char const *pszDir = NULL;
	if ( CommandLine()->CheckParm( "-reslistdir", &pszDir ) && pszDir )
	{
		char szDir[ MAX_PATH ];
		Q_strncpy( szDir, pszDir, sizeof( szDir ) );
		Q_StripTrailingSlash( szDir );
#ifdef WIN32
		Q_strlower( szDir );
#endif
		Q_FixSlashes( szDir );
		if ( Q_strlen( szDir ) > 0 )
		{
			m_sResListDir = szDir;
		}
	}

	// game directory has not been established yet, must derive ourselves
	char path[MAX_PATH];
	Q_snprintf( path, sizeof(path), "%s/%s", GetBaseDirectory(), CommandLine()->ParmValue( "-game", "hl2" ) );
	Q_FixSlashes( path );
#ifdef WIN32
	Q_strlower( path );
#endif
	m_sFullGamePath = path;

	// create file to dump out to
	char szDir[ MAX_PATH ];
	V_snprintf( szDir, sizeof( szDir ), "%s\\%s", m_sFullGamePath.String(), m_sResListDir.String() );
	g_pFullFileSystem->CreateDirHierarchy( szDir, "GAME" );

	g_pFullFileSystem->AddLoggingFunc( &LogAllFilesFunc );

	if ( !CommandLine()->FindParm( "-startmap" ) && !CommandLine()->FindParm( "-startstage" ) )
	{
		m_Logged.RemoveAll();
		g_pFullFileSystem->RemoveFile( CFmtStr( "%s\\%s\\%s", m_sFullGamePath.String(), m_sResListDir.String(), ALL_RESLIST_FILE ), "GAME" );
	}

#ifdef WIN32
	::GetCurrentDirectory( sizeof(m_szCurrentDir), m_szCurrentDir );
	Q_strncat( m_szCurrentDir, "\\", sizeof(m_szCurrentDir), 1 );
	_strlwr( m_szCurrentDir );
#else
	getcwd( m_szCurrentDir, sizeof(m_szCurrentDir) );
	Q_strncat( m_szCurrentDir, "/", sizeof(m_szCurrentDir), 1 );
#endif
}

void CLogAllFiles::Shutdown()
{
	if ( !m_bActive )
		return;

	m_bActive = false;

	if ( CommandLine()->CheckParm( "-makereslists" ) )
	{
		g_pFullFileSystem->RemoveLoggingFunc( &LogAllFilesFunc );
	}

	// Now load and sort all.lst
	SortResList( CFmtStr( "%s\\%s\\%s", m_sFullGamePath.String(), m_sResListDir.String(), ALL_RESLIST_FILE ), "GAME" );
	// Now load and sort engine.lst
	SortResList( CFmtStr( "%s\\%s\\%s", m_sFullGamePath.String(), m_sResListDir.String(), ENGINE_RESLIST_FILE ), "GAME" );

	m_Logged.Purge();
}

void CLogAllFiles::LogToAllReslist( char const *line )
{
	// Open for append, write data, close.
	FileHandle_t fh = g_pFullFileSystem->Open( CFmtStr( "%s\\%s\\%s", m_sFullGamePath.String(), m_sResListDir.String(), ALL_RESLIST_FILE ), "at", "GAME" );
	if ( fh != FILESYSTEM_INVALID_HANDLE )
	{
		g_pFullFileSystem->Write("\"", 1, fh);
		g_pFullFileSystem->Write( line, Q_strlen(line), fh );
		g_pFullFileSystem->Write("\"\n", 2, fh);
		g_pFullFileSystem->Close( fh );
	}
}

void CLogAllFiles::LogFile(const char *fullPathFileName, const char *options)
{
	if ( !m_bActive )
	{
		Assert( 0 );
		return;
	}

	// write out to log file
	Assert( fullPathFileName[1] == ':' );

	int idx = m_Logged.Find( fullPathFileName );
	if ( idx != m_Logged.InvalidIndex() )
	{
		return;
	}

	m_Logged.Insert( fullPathFileName );

	// make it relative to our root directory
	const char *relative = Q_stristr( fullPathFileName, GetBaseDirectory() );
	if ( relative )
	{
		relative += ( Q_strlen( GetBaseDirectory() ) + 1 );

		char rel[ MAX_PATH ];
		Q_strncpy( rel, relative, sizeof( rel ) );
#ifdef WIN32
		Q_strlower( rel );
#endif
		Q_FixSlashes( rel );
		
		LogToAllReslist( rel );
	}
}

//-----------------------------------------------------------------------------
// Purpose: callback function from filesystem
//-----------------------------------------------------------------------------
void CLogAllFiles::LogAllFilesFunc(const char *fullPathFileName, const char *options)
{
	g_LogFiles.LogFile( fullPathFileName, options );
}

//-----------------------------------------------------------------------------
// Purpose: This is a bit of a hack because it appears 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
static bool IsWin98OrOlder()
{
	bool retval = false;

#if defined( WIN32 ) && !defined( _X360 )
	OSVERSIONINFOEX osvi;
	ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
	
	BOOL bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi);
	if( !bOsVersionInfoEx )
	{
		// If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
		osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
		if ( !GetVersionEx ( (OSVERSIONINFO *) &osvi) )
		{
			Error( "IsWin98OrOlder:  Unable to get OS version information" );
		}
	}

	switch (osvi.dwPlatformId)
	{
	case VER_PLATFORM_WIN32_NT:
		// NT, XP, Win2K, etc. all OK for SSE
		break;
	case VER_PLATFORM_WIN32_WINDOWS:
		// Win95, 98, Me can't do SSE
		retval = true;
		break;
	case VER_PLATFORM_WIN32s:
		// Can't really run this way I don't think...
		retval = true;
		break;
	default:
		break;
	}
#endif

	return retval;
}


//-----------------------------------------------------------------------------
// Purpose: Figure out if Steam is running, then load the GameOverlayRenderer.dll
//-----------------------------------------------------------------------------
void TryToLoadSteamOverlayDLL()
{
#if defined( WIN32 ) && !defined( _X360 )
	// First, check if the module is already loaded, perhaps because we were run from Steam directly
	HMODULE hMod = GetModuleHandle( "GameOverlayRenderer" DLL_EXT_STRING );
	if ( hMod )
	{
		return;
	}

	if ( 0 == GetEnvironmentVariableA( "SteamGameId", NULL, 0 ) )
	{
		// Initializing the Steam client API has the side effect of setting up the AppId
		// which is immediately queried in GameOverlayRenderer.dll's DllMain entry point
		if( SteamAPI_InitSafe() )
		{
			const char *pchSteamInstallPath = SteamAPI_GetSteamInstallPath();
			if ( pchSteamInstallPath )
			{
				char rgchSteamPath[MAX_PATH];
				V_ComposeFileName( pchSteamInstallPath, "GameOverlayRenderer" DLL_EXT_STRING, rgchSteamPath, Q_ARRAYSIZE(rgchSteamPath) );
				// This could fail, but we can't fix it if it does so just ignore failures
				LoadLibrary( rgchSteamPath );
			
			}

			SteamAPI_Shutdown();
		}
	}

#endif
}

//-----------------------------------------------------------------------------
// Inner loop: initialize, shutdown main systems, load steam to 
//-----------------------------------------------------------------------------
class CSourceAppSystemGroup : public CSteamAppSystemGroup
{
public:
	// Methods of IApplication
	virtual bool Create();
	virtual bool PreInit();
	virtual int Main();
	virtual void PostShutdown();
	virtual void Destroy();

private:
	const char *DetermineDefaultMod();
	const char *DetermineDefaultGame();

	bool m_bEditMode;
};


//-----------------------------------------------------------------------------
// The dirty disk error report function
//-----------------------------------------------------------------------------
void ReportDirtyDiskNoMaterialSystem()
{
#ifdef _X360
	for ( int i = 0; i < 4; ++i )
	{
		if ( XUserGetSigninState( i ) != eXUserSigninState_NotSignedIn )
		{
			XShowDirtyDiscErrorUI( i );
			return;
		}
	}
	XShowDirtyDiscErrorUI( 0 );
#endif
}


//-----------------------------------------------------------------------------
// Instantiate all main libraries
//-----------------------------------------------------------------------------
bool CSourceAppSystemGroup::Create()
{
	IFileSystem *pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION );
	pFileSystem->InstallDirtyDiskReportFunc( ReportDirtyDiskNoMaterialSystem );

#ifdef WIN32
	CoInitialize( NULL );
#endif

	// Are we running in edit mode?
	m_bEditMode = CommandLine()->CheckParm( "-edit" );

	double st = Plat_FloatTime();

	AppSystemInfo_t appSystems[] = 
	{
		{ "engine" DLL_EXT_STRING,			CVAR_QUERY_INTERFACE_VERSION },	// NOTE: This one must be first!!
		{ "inputsystem" DLL_EXT_STRING,		INPUTSYSTEM_INTERFACE_VERSION },
		{ "materialsystem" DLL_EXT_STRING,	MATERIAL_SYSTEM_INTERFACE_VERSION },
		{ "datacache" DLL_EXT_STRING,		DATACACHE_INTERFACE_VERSION },
		{ "datacache" DLL_EXT_STRING,		MDLCACHE_INTERFACE_VERSION },
		{ "datacache" DLL_EXT_STRING,		STUDIO_DATA_CACHE_INTERFACE_VERSION },
		{ "studiorender" DLL_EXT_STRING,	STUDIO_RENDER_INTERFACE_VERSION },
		{ "vphysics" DLL_EXT_STRING,		VPHYSICS_INTERFACE_VERSION },
		{ "video_services" DLL_EXT_STRING,  VIDEO_SERVICES_INTERFACE_VERSION },
  
		// NOTE: This has to occur before vgui2.dll so it replaces vgui2's surface implementation
		{ "vguimatsurface" DLL_EXT_STRING,	VGUI_SURFACE_INTERFACE_VERSION },
		{ "vgui2" DLL_EXT_STRING,			VGUI_IVGUI_INTERFACE_VERSION },
		{ "engine" DLL_EXT_STRING,			VENGINE_LAUNCHER_API_VERSION },

		{ "", "" }							// Required to terminate the list
	};

#if defined( USE_SDL )
	AddSystem( (IAppSystem *)CreateSDLMgr(), SDLMGR_INTERFACE_VERSION );
#endif

	if ( !AddSystems( appSystems ) ) 
		return false;
	
	// This will be NULL for games that don't support VR. That's ok. Just don't load the DLL
	AppModule_t sourceVRModule = LoadModule( "sourcevr" DLL_EXT_STRING );
	if( sourceVRModule != APP_MODULE_INVALID )
	{
		AddSystem( sourceVRModule, SOURCE_VIRTUAL_REALITY_INTERFACE_VERSION );
	}

	// pull in our filesystem dll to pull the queued loader from it, we need to do it this way due to the 
	// steam/stdio split for our steam filesystem
	char pFileSystemDLL[MAX_PATH];
	bool bSteam;
	if ( FileSystem_GetFileSystemDLLName( pFileSystemDLL, MAX_PATH, bSteam ) != FS_OK )
		return false;

	AppModule_t fileSystemModule = LoadModule( pFileSystemDLL );
	AddSystem( fileSystemModule, QUEUEDLOADER_INTERFACE_VERSION );

	// Hook in datamodel and p4 control if we're running with -tools
	if ( IsPC() && ( ( CommandLine()->FindParm( "-tools" ) && !CommandLine()->FindParm( "-nop4" ) ) || CommandLine()->FindParm( "-p4" ) ) )
	{
#ifdef STAGING_ONLY
		AppModule_t p4libModule = LoadModule( "p4lib" DLL_EXT_STRING );
		IP4 *p4 = (IP4*)AddSystem( p4libModule, P4_INTERFACE_VERSION );
		
		// If we are running with -steam then that means the tools are being used by an SDK user. Don't exit in this case!
		if ( !p4 && !CommandLine()->FindParm( "-steam" ) )
		{
			return false;
		}
#endif // STAGING_ONLY

		AppModule_t vstdlibModule = LoadModule( "vstdlib" DLL_EXT_STRING );
		IProcessUtils *processUtils = ( IProcessUtils* )AddSystem( vstdlibModule, PROCESS_UTILS_INTERFACE_VERSION );
		if ( !processUtils )
			return false;
	}

	// Connect to iterfaces loaded in AddSystems that we need locally
	IMaterialSystem *pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
	if ( !pMaterialSystem )
		return false;

	g_pEngineAPI = (IEngineAPI*)FindSystem( VENGINE_LAUNCHER_API_VERSION );

	// Load the hammer DLL if we're in editor mode
#if defined( _WIN32 ) && defined( STAGING_ONLY )
	if ( m_bEditMode )
	{
		AppModule_t hammerModule = LoadModule( "hammer_dll" DLL_EXT_STRING );
		g_pHammer = (IHammer*)AddSystem( hammerModule, INTERFACEVERSION_HAMMER );
		if ( !g_pHammer )
		{
			return false;
		}
	}
#endif // defined( _WIN32 ) && defined( STAGING_ONLY )

	// Load up the appropriate shader DLL
	// This has to be done before connection.
	char const* pDLLName = "shaderapidx9" DLL_EXT_STRING;
	if ( CommandLine()->FindParm( "-noshaderapi" ) )
	{
		pDLLName = "shaderapiempty" DLL_EXT_STRING;
	}

	pMaterialSystem->SetShaderAPI( pDLLName );

	double elapsed = Plat_FloatTime() - st;
	COM_TimestampedLog( "LoadAppSystems:  Took %.4f secs to load libraries and get factories.", (float)elapsed );

	return true;
}

bool CSourceAppSystemGroup::PreInit()
{
	if ( !CommandLine()->FindParm( "-nolog" ) )
		DebugLogger()->Init("engine.log");

	CreateInterfaceFn factory = GetFactory();
	ConnectTier1Libraries( &factory, 1 );
	ConVar_Register( );
	ConnectTier2Libraries( &factory, 1 );
	ConnectTier3Libraries( &factory, 1 );

	if ( !g_pFullFileSystem || !g_pMaterialSystem )
		return false;

	CFSSteamSetupInfo steamInfo;
	steamInfo.m_bToolsMode = false;
	steamInfo.m_bSetSteamDLLPath = false;
	steamInfo.m_bSteam = g_pFullFileSystem->IsSteam();
	steamInfo.m_bOnlyUseDirectoryName = true;
	steamInfo.m_pDirectoryName = DetermineDefaultMod();
	if ( !steamInfo.m_pDirectoryName )
	{
		steamInfo.m_pDirectoryName = DetermineDefaultGame();
		if ( !steamInfo.m_pDirectoryName )
		{
			Error( "FileSystem_LoadFileSystemModule: no -defaultgamedir or -game specified." );
		}
	}
	if ( FileSystem_SetupSteamEnvironment( steamInfo ) != FS_OK )
		return false;

	CFSMountContentInfo fsInfo;
	fsInfo.m_pFileSystem = g_pFullFileSystem;
	fsInfo.m_bToolsMode = m_bEditMode;
	fsInfo.m_pDirectoryName = steamInfo.m_GameInfoPath;
	if ( FileSystem_MountContent( fsInfo ) != FS_OK )
		return false;

	if ( IsPC() || !IsX360() )
	{
		fsInfo.m_pFileSystem->AddSearchPath( "platform", "PLATFORM" );
	}
	else
	{
		// 360 needs absolute paths
		FileSystem_AddSearchPath_Platform( g_pFullFileSystem, steamInfo.m_GameInfoPath );
	}

	if ( IsPC() )
	{
		// This will get called multiple times due to being here, but only the first one will do anything
		reslistgenerator->Init( GetBaseDirectory(), CommandLine()->ParmValue( "-game", "hl2" ) );

		// This will also get called each time, but will actually fix up the command line as needed
		reslistgenerator->SetupCommandLine();
	}

	// FIXME: Logfiles is mod-specific, needs to move into the engine.
	g_LogFiles.Init();

	// Required to run through the editor
	if ( m_bEditMode )
	{
		g_pMaterialSystem->EnableEditorMaterials();	
	}

	StartupInfo_t info;
	info.m_pInstance = GetAppInstance();
	info.m_pBaseDirectory = GetBaseDirectory();
	info.m_pInitialMod = DetermineDefaultMod();
	info.m_pInitialGame = DetermineDefaultGame();
	info.m_pParentAppSystemGroup = this;
	info.m_bTextMode = g_bTextMode;

	g_pEngineAPI->SetStartupInfo( info );

	return true;
}

int CSourceAppSystemGroup::Main()
{
	return g_pEngineAPI->Run();
}

void CSourceAppSystemGroup::PostShutdown()
{
	// FIXME: Logfiles is mod-specific, needs to move into the engine.
	g_LogFiles.Shutdown();

	reslistgenerator->Shutdown();

	DisconnectTier3Libraries();
	DisconnectTier2Libraries();
	ConVar_Unregister( );
	DisconnectTier1Libraries();
}

void CSourceAppSystemGroup::Destroy() 
{
	g_pEngineAPI = NULL;
	g_pMaterialSystem = NULL;
	g_pHammer = NULL;

#ifdef WIN32
	CoUninitialize();
#endif
}


//-----------------------------------------------------------------------------
// Determines the initial mod to use at load time.
// We eventually (hopefully) will be able to switch mods at runtime
// because the engine/hammer integration really wants this feature.
//-----------------------------------------------------------------------------
const char *CSourceAppSystemGroup::DetermineDefaultMod()
{
	if ( !m_bEditMode )
	{   		 
		return CommandLine()->ParmValue( "-game", DEFAULT_HL2_GAMEDIR );
	}
	return g_pHammer->GetDefaultMod();
}

const char *CSourceAppSystemGroup::DetermineDefaultGame()
{
	if ( !m_bEditMode )
	{
		return CommandLine()->ParmValue( "-defaultgamedir", DEFAULT_HL2_GAMEDIR );
	}
	return g_pHammer->GetDefaultGame();
}

//-----------------------------------------------------------------------------
// MessageBox for SDL/OSX
//-----------------------------------------------------------------------------
#if defined( USE_SDL ) && !defined( _WIN32 )

int MessageBox( HWND hWnd, const char *message, const char *header, unsigned uType )
{
	SDL_ShowSimpleMessageBox( 0, header, message, GetAssertDialogParent() );
	return 0;
}

#endif

//-----------------------------------------------------------------------------
// Allow only one windowed source app to run at a time
//-----------------------------------------------------------------------------
#ifdef WIN32
HANDLE g_hMutex = NULL;
#elif defined(POSIX)
int g_lockfd = -1;
char g_lockFilename[MAX_PATH];
#endif
bool GrabSourceMutex()
{
#ifdef WIN32
	if ( IsPC() )
	{
		// don't allow more than one instance to run
		g_hMutex = ::CreateMutex(NULL, FALSE, TEXT("hl2_singleton_mutex"));

		unsigned int waitResult = ::WaitForSingleObject(g_hMutex, 0);

		// Here, we have the mutex
		if (waitResult == WAIT_OBJECT_0 || waitResult == WAIT_ABANDONED)
			return true;

		// couldn't get the mutex, we must be running another instance
		::CloseHandle(g_hMutex);

		return false;
	}
#elif defined(POSIX)

	// Under OSX use flock in /tmp/source_engine_<game>.lock, create the file if it doesn't exist
	const char *pchGameParam = CommandLine()->ParmValue( "-game", DEFAULT_HL2_GAMEDIR );
	CRC32_t gameCRC;
	CRC32_Init(&gameCRC);
	CRC32_ProcessBuffer( &gameCRC, (void *)pchGameParam, Q_strlen( pchGameParam ) );
	CRC32_Final( &gameCRC );

#ifdef ANDROID
	return true;
#elif defined (LINUX)
	/*
	 * Linux
 	 */

	// Check TMPDIR environment variable for temp directory.
	char *tmpdir = getenv( "TMPDIR" );

	// If it's NULL, or it doesn't exist, or it isn't a directory, fallback to /tmp.
	struct stat buf;
	if( !tmpdir || stat( tmpdir, &buf ) || !S_ISDIR ( buf.st_mode ) )
		tmpdir = "/tmp";

	V_snprintf( g_lockFilename, sizeof(g_lockFilename), "%s/source_engine_%u.lock", tmpdir, gameCRC );

	g_lockfd = open( g_lockFilename, O_WRONLY | O_CREAT, 0666 );
	if ( g_lockfd == -1 )
	{
		printf( "open(%s) failed\n", g_lockFilename );
		return false;
	}

	struct flock fl;
	fl.l_type = F_WRLCK;
	fl.l_whence = SEEK_SET;
	fl.l_start = 0;
	fl.l_len = 1;

	if ( fcntl ( g_lockfd, F_SETLK, &fl ) == -1 )
	{
		printf( "fcntl(%d) for %s failed\n", g_lockfd, g_lockFilename );
		return false;
	}

	return true;
#else
	/*
	 * OSX
 	 */
	V_snprintf( g_lockFilename, sizeof(g_lockFilename), "/tmp/source_engine_%u.lock", gameCRC );

	g_lockfd = open( g_lockFilename, O_CREAT | O_WRONLY | O_EXLOCK | O_NONBLOCK | O_TRUNC, 0777 );
	if (g_lockfd >= 0)
	{
		// make sure we give full perms to the file, we only one instance per machine
		fchmod( g_lockfd, 0777 );

		// we leave the file open, under unix rules when we die we'll automatically close and remove the locks
		return true;
	}   		 

	// We were unable to open the file, it should be because we are unable to retain a lock
	if ( errno != EWOULDBLOCK)
	{
		fprintf( stderr, "unexpected error %d trying to exclusively lock %s\n", errno, g_lockFilename );
	}

	return false;
#endif // OSX

#endif // POSIX
	return true;
}

void ReleaseSourceMutex()
{
#ifdef WIN32
	if ( IsPC() && g_hMutex )
	{
		::ReleaseMutex( g_hMutex );
		::CloseHandle( g_hMutex );
		g_hMutex = NULL;
	}
#elif defined(POSIX)
	if ( g_lockfd != -1 )
	{
		close( g_lockfd );
		g_lockfd = -1;
		unlink( g_lockFilename ); 
	}
#endif
}

// Remove all but the last -game parameter.
// This is for mods based off something other than Half-Life 2 (like HL2MP mods).
// The Steam UI does 'steam -applaunch 320 -game c:\steam\steamapps\sourcemods\modname', but applaunch inserts
// its own -game parameter, which would supercede the one we really want if we didn't intercede here.
void RemoveSpuriousGameParameters()
{
	// Find the last -game parameter.
	int nGameArgs = 0;
	char lastGameArg[MAX_PATH];
	for ( int i=0; i < CommandLine()->ParmCount()-1; i++ )
	{
		if ( Q_stricmp( CommandLine()->GetParm( i ), "-game" ) == 0 )
		{
			Q_snprintf( lastGameArg, sizeof( lastGameArg ), "\"%s\"", CommandLine()->GetParm( i+1 ) );
			++nGameArgs;
			++i;
		}
	}

	// We only care if > 1 was specified.
	if ( nGameArgs > 1 )
	{
		CommandLine()->RemoveParm( "-game" );
		CommandLine()->AppendParm( "-game", lastGameArg );
	}
}

/*
============
va

does a varargs printf into a temp buffer, so I don't need to have
varargs versions of all text functions.
============
*/
static char *va( char *format, ... )
{
	va_list		argptr;
	static char	string[8][512];
	static int	curstring = 0;

	curstring = ( curstring + 1 ) % 8;

	va_start (argptr, format);
	Q_vsnprintf( string[curstring], sizeof( string[curstring] ), format, argptr );
	va_end (argptr);

	return string[curstring];  
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *param - 
// Output : static char const
//-----------------------------------------------------------------------------
static char const *Cmd_TranslateFileAssociation(char const *param )
{
	static char sz[ 512 ];
	char *retval = NULL;

	char temp[ 512 ];
	Q_strncpy( temp, param, sizeof( temp ) );
	Q_FixSlashes( temp );
#ifdef WIN32
	Q_strlower( temp );
#endif
	const char *extension = V_GetFileExtension(temp);
	// must have an extension to map
	if (!extension)
		return retval;
	extension--; // back up so we have the . in the extension

	int c = ARRAYSIZE( g_FileAssociations );
	for ( int i = 0; i < c; i++ )
	{
		FileAssociationInfo& info = g_FileAssociations[ i ];

		if ( ! Q_strcmp( extension, info.extension ) && 
			! CommandLine()->FindParm(va( "+%s", info.command_to_issue ) ) )
		{
			// Translate if haven't already got one of these commands			
			Q_strncpy( sz, temp, sizeof( sz ) );
			Q_FileBase( sz, temp, sizeof( sz ) );

			Q_snprintf( sz, sizeof( sz ), "%s %s", info.command_to_issue, temp );
			retval = sz;
			break;
		}		
	}

	// return null if no translation, otherwise return commands
	return retval;
}

//-----------------------------------------------------------------------------
// Purpose: Converts all the convar args into a convar command
// Input  : none 
// Output : const char * series of convars
//-----------------------------------------------------------------------------
static const char *BuildCommand()
{
	static CUtlBuffer build( 0, 0, CUtlBuffer::TEXT_BUFFER );
	build.Clear();

	// arg[0] is the executable name
	for ( int i=1; i < CommandLine()->ParmCount(); i++ )
	{
		const char *szParm = CommandLine()->GetParm(i);
		if (!szParm) continue;

		if (szParm[0] == '-') 
		{
			// skip -XXX options and eat their args
			const char *szValue = CommandLine()->ParmValue(szParm);
			if ( szValue ) i++;
			continue;
		}
		if (szParm[0] == '+')
		{
			// convert +XXX options and stuff them into the build buffer
			const char *szValue = CommandLine()->ParmValue(szParm);
			if (szValue)
			{
				build.PutString(va("%s %s;", szParm+1, szValue));
				i++;
			}
			else
			{
				build.PutString(szParm+1);
				build.PutChar(';');
			}
		}
		else 
		{
			// singleton values, convert to command
			char const *translated = Cmd_TranslateFileAssociation( CommandLine()->GetParm( i ) );
			if (translated)
			{
				build.PutString(translated);
				build.PutChar(';');
			}
		}
	}

	build.PutChar( '\0' );

	return (const char *)build.Base();
}

extern void InitGL4ES();

//-----------------------------------------------------------------------------
// Purpose: The real entry point for the application
// Input  : hInstance - 
//			hPrevInstance - 
//			lpCmdLine - 
//			nCmdShow - 
// Output : int APIENTRY
//-----------------------------------------------------------------------------
#ifdef WIN32
DLL_EXPORT int LauncherMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
#else
DLL_EXPORT int LauncherMain( int argc, char **argv )
#endif
{
#if defined LINUX && !defined ANDROID
	// Temporary fix to stop us from crashing in printf/sscanf functions that don't expect
	//  localization to mess with your "." and "," float seperators. Mac OSX also sets LANG
	//  to en_US.UTF-8 before starting up (in info.plist I believe).
	// We need to double check that localization for libcef is handled correctly
	//  when we slam things to en_US.UTF-8.
	// Also check if C.UTF-8 exists and use it? This file: /usr/lib/locale/C.UTF-8.
	// It looks like it's only installed on Debian distros right now though.
	const char en_US[] = "en_US.UTF-8";

	setenv( "LC_ALL", en_US, 1 );
	setlocale( LC_ALL, en_US );

	const char *CurrentLocale = setlocale( LC_ALL, NULL );
	if ( Q_stricmp( CurrentLocale, en_US ) )
	{
		Msg( "WARNING: setlocale('%s') failed, using locale:'%s'. International characters may not work.\n", en_US, CurrentLocale );
	}

#endif // LINUX

#if defined LINUX && defined USE_SDL && defined TOGLES && !defined ANDROID
	SDL_SetHint(SDL_HINT_VIDEO_X11_FORCE_EGL, "1");
#endif

#ifdef WIN32
	SetAppInstance( hInstance );
#elif defined( POSIX )
	// Store off command line for argument searching
	Plat_SetCommandLine( BuildCmdLine( argc, argv, false ) );

	if( CommandLine()->CheckParm( "-sleepatstartup" ) )
	{
		// When launching from Steam, it can be difficult to get a debugger attached when you're
		//	crashing quickly at startup. So add a -sleepatstartup command line and sleep for 5
		//	seconds which should allow time to attach a debugger.
		sleep( 5 );
	}
#endif

	// Hook the debug output stuff.
	SpewOutputFunc( LauncherDefaultSpewFunc );

	if ( 0 && IsWin98OrOlder() )
	{
		Error( "This build does not currently run under Windows 98/Me." );
		return -1;
	}

	// Quickly check the hardware key, essentially a warning shot.  
	if ( !Plat_VerifyHardwareKeyPrompt() )
	{
		return -1;
	}
	
	const char *filename;
#ifdef WIN32
	CommandLine()->CreateCmdLine( IsPC() ? VCRHook_GetCommandLine() : lpCmdLine );
#else
	CommandLine()->CreateCmdLine( argc, argv );
#endif

	// No -dxlevel or +mat_hdr_level allowed on POSIX
#ifdef POSIX	
	CommandLine()->RemoveParm( "-dxlevel" );
	CommandLine()->RemoveParm( "+mat_hdr_level" );
	CommandLine()->RemoveParm( "+mat_dxlevel" );
#endif

	// If we're using -default command line parameters, get rid of DX8 settings. 
	if ( CommandLine()->CheckParm( "-default" ) )
	{
		CommandLine()->RemoveParm( "-dxlevel" );
		CommandLine()->RemoveParm( "-maxdxlevel" );
		CommandLine()->RemoveParm( "+mat_dxlevel" );
	}
	
	// Figure out the directory the executable is running from
	UTIL_ComputeBaseDir();

#if defined( _X360 )
	bool bSpewDllInfo = CommandLine()->CheckParm( "-dllinfo" );
	bool bWaitForConsole = CommandLine()->CheckParm( "-vxconsole" );
	XboxConsoleInit();
	XBX_InitConsoleMonitor( bWaitForConsole || bSpewDllInfo );
#endif


#if defined( _X360 )
	if ( bWaitForConsole )
		COM_TimestampedLog( "LauncherMain: Application Start - %s", CommandLine()->GetCmdLine() );
	if ( bSpewDllInfo )
	{	
		XBX_DumpDllInfo( GetBaseDirectory() );
		Error( "Stopped!\n" );
	}

	int storageID = XboxLaunch()->GetStorageID();
	if ( storageID != XBX_INVALID_STORAGE_ID && storageID != XBX_STORAGE_DECLINED )
	{
		// Validate the storage device
		XDEVICE_DATA deviceData;
		DWORD ret = XContentGetDeviceData( storageID, &deviceData );
		if ( ret != ERROR_SUCCESS )
		{
			// Device was removed
			storageID = XBX_INVALID_STORAGE_ID;
			XBX_QueueEvent( XEV_LISTENER_NOTIFICATION, WM_SYS_STORAGEDEVICESCHANGED, 0, 0 );
		}
	}
	XBX_SetStorageDeviceId( storageID );

	int userID = XboxLaunch()->GetUserID();
	if ( !IsRetail() && userID == XBX_INVALID_USER_ID )
	{
		// didn't come from appchooser, try find a valid user id for dev purposes
		XUSER_SIGNIN_INFO info;
		for ( int i = 0; i < 4; ++i )
		{
			if ( ERROR_NO_SUCH_USER != XUserGetSigninInfo( i, 0, &info ) )
			{
				userID = i;
				break;
			}
		}
	}
	XBX_SetPrimaryUserId( userID );
#endif // defined( _X360 )
	
#ifdef POSIX
	{
		struct stat st;
		if ( stat( RELAUNCH_FILE, &st ) == 0 ) 
		{
			unlink( RELAUNCH_FILE );
		}
	}
#endif

	// This call is to emulate steam's injection of the GameOverlay DLL into our process if we
	// are running from the command line directly, this allows the same experience the user gets
	// to be present when running from perforce, the call has no effect on X360
	TryToLoadSteamOverlayDLL();

	// Start VCR mode?
	if ( CommandLine()->CheckParm( "-vcrrecord", &filename ) )
	{
		if ( !VCRStart( filename, true, &g_VCRHelpers ) )
		{
			Error( "-vcrrecord: can't open '%s' for writing.\n", filename );
			return -1;
		}
	}
	else if ( CommandLine()->CheckParm( "-vcrplayback", &filename ) )
	{
		if ( !VCRStart( filename, false, &g_VCRHelpers ) )
		{
			Error( "-vcrplayback: can't open '%s' for reading.\n", filename );
			return -1;
		}
	}

	// See the function for why we do this.
	RemoveSpuriousGameParameters();

#ifdef WIN32
	if ( IsPC() )
	{
		// initialize winsock
		WSAData wsaData;
		int	nError = ::WSAStartup( MAKEWORD(2,0), &wsaData );
		if ( nError )
		{
			Msg( "Warning! Failed to start Winsock via WSAStartup = 0x%x.\n", nError);
		}
	}
#endif

	// Run in text mode? (No graphics or sound).
	if ( CommandLine()->CheckParm( "-textmode" ) )
	{
		g_bTextMode = true;
		InitTextMode();
	}
#ifdef WIN32
	else
	{
		int retval = -1;
		// Can only run one windowed source app at a time
		if ( !GrabSourceMutex() )
		{
			// Allow the user to explicitly say they want to be able to run multiple instances of the source mutex.
			// Useful for side-by-side comparisons of different renderers.
			bool multiRun = CommandLine()->CheckParm( "-multirun" ) != NULL;

			// We're going to hijack the existing session and load a new savegame into it. This will mainly occur when users click on links in Bugzilla that will automatically copy saves and load them
			// directly from the web browser. The -hijack command prevents the launcher from objecting that there is already an instance of the game.
			if (CommandLine()->CheckParm( "-hijack" ))
			{
				HWND hwndEngine = FindWindow( "Valve001", NULL );

				// Can't find the engine
				if ( hwndEngine == NULL )
				{
					::MessageBox( NULL, "The modified entity keyvalues could not be sent to the Source Engine because the engine does not appear to be running.", "Source Engine Not Running", MB_OK | MB_ICONEXCLAMATION );
				}
				else
				{			
					const char *szCommand = BuildCommand();

					//
					// Fill out the data structure to send to the engine.
					//
					COPYDATASTRUCT copyData;
					copyData.cbData = strlen( szCommand ) + 1;
					copyData.dwData = 0;
					copyData.lpData = ( void * )szCommand;

					if ( !::SendMessage( hwndEngine, WM_COPYDATA, 0, (LPARAM)&copyData ) )
					{
						::MessageBox( NULL, "The Source Engine was found running, but did not accept the request to load a savegame. It may be an old version of the engine that does not support this functionality.", "Source Engine Declined Request", MB_OK | MB_ICONEXCLAMATION );
					}
					else
					{
						retval = 0;
					}

					free((void *)szCommand);
				}
			}
			else
			{
				if (!multiRun) {
					::MessageBox(NULL, "Only one instance of the game can be running at one time.", "Source - Warning", MB_ICONINFORMATION | MB_OK);
				}
			}

			if (!multiRun) {
				return retval;
			}
		}
	}
#elif defined( POSIX )
	else
	{
		if ( !GrabSourceMutex() )
		{
			::MessageBox(NULL, "Only one instance of the game can be running at one time.", "Source - Warning", 0 );
			return -1;
		}
	}
#endif

#ifdef WIN32
	// Make low priority?
	if ( CommandLine()->CheckParm( "-low" ) )
	{
		SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
	}
	else if ( CommandLine()->CheckParm( "-high" ) )
	{
		SetPriorityClass( GetCurrentProcess(), HIGH_PRIORITY_CLASS );
	}
#endif

	// If game is not run from Steam then add -insecure in order to avoid client timeout message
	if ( NULL == CommandLine()->CheckParm( "-steam" ) )
	{
		CommandLine()->AppendParm( "-insecure", NULL );
	}

	// Figure out the directory the executable is running from
	// and make that be the current working directory

	_chdir( GetBaseDirectory() );

	g_LeakDump.m_bCheckLeaks = CommandLine()->CheckParm( "-leakcheck" ) ? true : false;

	bool bRestart = true;
	while ( bRestart )
	{
		bRestart = false;

		CSourceAppSystemGroup sourceSystems;
		CSteamApplication steamApplication( &sourceSystems );
		int nRetval = steamApplication.Run();
		if ( steamApplication.GetErrorStage() == CSourceAppSystemGroup::INITIALIZATION )
		{
			bRestart = (nRetval == INIT_RESTART);
		}
		else if ( nRetval == RUN_RESTART )
		{
			bRestart = true;
		}

		bool bReslistCycle = false;
		if ( !bRestart )
		{
			bReslistCycle = reslistgenerator->ShouldContinue();
			bRestart = bReslistCycle;
		}
		
		if ( !bReslistCycle )
		{
			// Remove any overrides in case settings changed
			CommandLine()->RemoveParm( "-w" );
			CommandLine()->RemoveParm( "-h" );
			CommandLine()->RemoveParm( "-width" );
			CommandLine()->RemoveParm( "-height" );
			CommandLine()->RemoveParm( "-sw" );
			CommandLine()->RemoveParm( "-startwindowed" );
			CommandLine()->RemoveParm( "-windowed" );
			CommandLine()->RemoveParm( "-window" );
			CommandLine()->RemoveParm( "-full" );
			CommandLine()->RemoveParm( "-fullscreen" );
			CommandLine()->RemoveParm( "-dxlevel" );
			CommandLine()->RemoveParm( "-autoconfig" );
			CommandLine()->RemoveParm( "+mat_hdr_level" );
		}
	}

#ifdef WIN32
	if ( IsPC() )
	{
		// shutdown winsock
		int nError = ::WSACleanup();
		if ( nError )
		{
			Msg( "Warning! Failed to complete WSACleanup = 0x%x.\n", nError );
		}
	}
#endif

	// Allow other source apps to run
	ReleaseSourceMutex();

#if defined( WIN32 ) && !defined( _X360 )

	// Now that the mutex has been released, check HKEY_CURRENT_USER\Software\Valve\Source\Relaunch URL. If there is a URL here, exec it.
	// This supports the capability of immediately re-launching the the game via Steam in a different audio language 
	HKEY hKey; 
	if ( RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\Valve\\Source", NULL, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS )
	{
		char szValue[MAX_PATH];
		DWORD dwValueLen = MAX_PATH;

		if ( RegQueryValueEx( hKey, "Relaunch URL", NULL, NULL, (unsigned char*)szValue, &dwValueLen ) == ERROR_SUCCESS )
		{
			ShellExecute (0, "open", szValue, 0, 0, SW_SHOW);
			RegDeleteValue( hKey, "Relaunch URL" );
		}

		RegCloseKey(hKey);
	}

#elif defined( OSX ) || defined( LINUX )
	struct stat st;
	if ( stat( RELAUNCH_FILE, &st ) == 0 ) 
	{
		FILE *fp = fopen( RELAUNCH_FILE, "r" );
		if ( fp )
		{
			char szCmd[256];
			int nChars = fread( szCmd, 1, sizeof(szCmd), fp );
			if ( nChars > 0 )
			{
				if ( nChars > (sizeof(szCmd)-1) )
				{
					nChars = (sizeof(szCmd)-1);
				}
				szCmd[nChars] = 0;
				char szOpenLine[ MAX_PATH ];
				#if defined( LINUX )
					Q_snprintf( szOpenLine, sizeof(szOpenLine), "xdg-open \"%s\"", szCmd );
				#else
					Q_snprintf( szOpenLine, sizeof(szOpenLine), "open \"%s\"", szCmd );
				#endif
				system( szOpenLine );
			}
			fclose( fp );
			unlink( RELAUNCH_FILE );
		}
	}
#elif defined( _X360 )
#else
#error
#endif

	return 0;
}