//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
bool CHLModelViewerApp::PreInit( )
{
CreateInterfaceFn factory = GetFactory();
ConnectTier1Libraries( &factory, 1 );
ConVar_Register( 0 );
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
// Add paths...
if ( !SetupSearchPaths( NULL, false, true ) )
return false;
// Get the adapter from the command line....
const char *pAdapterString;
int nAdapter = 0;
if (CommandLine()->CheckParm( "-adapter", &pAdapterString ))
{
nAdapter = atoi( pAdapterString );
}
int nAdapterFlags = 0;
if ( CommandLine()->CheckParm( "-ref" ) )
{
nAdapterFlags |= MATERIAL_INIT_REFERENCE_RASTERIZER;
}
g_pMaterialSystem->SetAdapter( nAdapter, nAdapterFlags );
if ( !g_pFileSystem->IsSteam() || CommandLine()->FindParm( "-OldDialogs" ) )
g_bOldFileDialogs = true;
LoadFileSystemDialogModule();
return true;
}
int GetDefaultDepthFeatheringValue( void ) //Allow the command-line to go against the default soft-particle value
{
static int iRetVal = -1;
if ( iRetVal == -1 )
{
#if ( DEFAULT_PARTICLE_FEATHERING_ENABLED == 1 )
{
if ( CommandLine()->CheckParm( "-softparticlesdefaultoff" ) )
iRetVal = 0;
else
iRetVal = 1;
}
#else
{
if ( CommandLine()->CheckParm( "-softparticlesdefaulton" ) )
iRetVal = 1;
else
iRetVal = 0;
}
#endif
}
return iRetVal;
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
bool CVMTEditApp::PreInit( IAppSystemGroup *pAppSystemGroup )
{
// initialize interfaces
CreateInterfaceFn appFactory = pAppSystemGroup->GetFactory();
if (!vgui::VGui_InitInterfacesList( "VMTEDIT", &appFactory, 1 ))
return false;
g_pMatSystemSurface = (IMatSystemSurface *)pAppSystemGroup->FindSystem(MAT_SYSTEM_SURFACE_INTERFACE_VERSION);
char *pArg;
int iWidth = 1024;
int iHeight = 768;
bool bWindowed = (CommandLine()->CheckParm( "-fullscreen" ) == NULL);
if (CommandLine()->CheckParm( "-width", &pArg ))
{
iWidth = atoi( pArg );
}
if (CommandLine()->CheckParm( "-height", &pArg ))
{
iHeight = atoi( pArg );
}
if (!CreateAppWindow( "VMTEdit", bWindowed, iWidth, iHeight ))
return false;
g_pMatSystemSurface->AttachToWindow( m_HWnd );
// NOTE: If we specifically wanted to use a particular shader DLL, we set it here...
//g_pMaterialSystem->SetShader( "shaderapidx8" );
return true;
}
//-----------------------------------------------------------------------------
// Returns the name of the file system DLL to use
//-----------------------------------------------------------------------------
FSReturnCode_t FileSystem_GetFileSystemDLLName( char *pFileSystemDLL, int nMaxLen, bool &bSteam )
{
bSteam = false;
// Inside of here, we don't have a filesystem yet, so we have to assume that the filesystem_stdio or filesystem_steam
// is in this same directory with us.
char executablePath[MAX_PATH];
if ( !FileSystem_GetExecutableDir( executablePath, sizeof( executablePath ) ) )
return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetExecutableDir failed." );
#if defined( _WIN32 )
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_stdio.dll", executablePath, CORRECT_PATH_SEPARATOR );
#elif defined( POSIX )
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_stdio", executablePath, CORRECT_PATH_SEPARATOR );
struct stat statBuf;
if ( CommandLine()->FindParm( "-steam" ) || CommandLine()->FindParm( "-steamlocal" ) || stat( pFileSystemDLL, &statBuf ) != 0 )
{
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_steam.dylib", executablePath, CORRECT_PATH_SEPARATOR );
bSteam = true;
}
#else
#error "define a filesystem dll name"
#endif
return FS_OK;
}
//-----------------------------------------------------------------------------
// Returns the name of the file system DLL to use
//-----------------------------------------------------------------------------
FSReturnCode_t FileSystem_GetFileSystemDLLName( char *pFileSystemDLL, int nMaxLen, bool &bSteam )
{
bSteam = false;
// Inside of here, we don't have a filesystem yet, so we have to assume that the filesystem_stdio or filesystem_steam
// is in this same directory with us.
char executablePath[MAX_PATH];
if ( !FileSystem_GetExecutableDir( executablePath, sizeof( executablePath ) ) )
return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetExecutableDir failed." );
#if defined( _WIN32 ) && !defined( _X360 )
// If filesystem_stdio.dll is missing or -steam is specified, then load filesystem_steam.dll.
// There are two command line parameters for Steam:
// 1) -steam (runs Steam in remote filesystem mode; requires Steam backend)
// 2) -steamlocal (runs Steam in local filesystem mode (all content off HDD)
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_stdio.dll", executablePath, CORRECT_PATH_SEPARATOR );
if ( CommandLine()->FindParm( "-steam" ) || CommandLine()->FindParm( "-steamlocal" ) || _access( pFileSystemDLL, 0 ) != 0 )
{
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_steam.dll", executablePath, CORRECT_PATH_SEPARATOR );
bSteam = true;
}
#elif defined( _X360 )
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_stdio.dll", executablePath, CORRECT_PATH_SEPARATOR );
#elif defined( _LINUX )
Q_snprintf( pFileSystemDLL, nMaxLen, "%s%cfilesystem_i486.so", executablePath, CORRECT_PATH_SEPARATOR );
#else
#error "define a filesystem dll name"
#endif
return FS_OK;
}
//-----------------------------------------------------------------------------
// PreInit, PostShutdown
//-----------------------------------------------------------------------------
bool CInputTestApp::PreInit( )
{
if ( !BaseClass::PreInit() )
return false;
if (!g_pFullFileSystem || !g_pInputSystem )
return false;
// Add paths...
if ( !SetupSearchPaths() )
return false;
const char *pArg;
int iWidth = 1024;
int iHeight = 768;
bool bWindowed = (CommandLine()->CheckParm( "-fullscreen" ) == NULL);
if (CommandLine()->CheckParm( "-width", &pArg ))
{
iWidth = atoi( pArg );
}
if (CommandLine()->CheckParm( "-height", &pArg ))
{
iHeight = atoi( pArg );
}
if (!CreateAppWindow( "InputTest", bWindowed, iWidth, iHeight ))
return false;
g_pInputSystem->AttachToWindow( m_HWnd );
return true;
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//---------------------------------------------------------------------------------
bool CEmptyServerPlugin::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
//ConnectTier1Libraries( &interfaceFactory, 1 );
pEngine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL);
if (!pEngine){
Warning( "Unable to load IVEngineServer, aborting load\n" );
return false;
}
// assuming that the value of host_timer_spin_ms is 0 by any server configs
if ( CommandLine()->CheckParm( "+host_timer_spin_ms" ) )
{
m_bCommandPresent = 1;
m_iDefaultValue = CommandLine()->ParmValue( "+host_timer_spin_ms", 0 );
if ( m_iDefaultValue < 0 )
m_iDefaultValue = 0;
else if ( m_iDefaultValue > 15 )
m_iDefaultValue = 15; // god knows who would do this (idiots)
CommandLine()->RemoveParm( "+host_timer_spin_ms" );
}
//pEngine->ServerCommand( "con_logfile autotimer.log\n" );
//ConVar_Register( 0 );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : argc -
// argv[] -
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
SpewOutputFunc( SpewFunc );
Msg( "Valve Software - vcprojtomake.exe (%s)\n", __DATE__ );
Msg( "Modified for VS2010 Support by Killer Monkey\n" );
Msg( "<*****@*****.**>\n" );
CommandLine()->CreateCmdLine( argc, argv );
if ( CommandLine()->ParmCount() < 2)
{
printusage();
return 0;
}
CVCProjConvert proj;
if ( !proj.LoadProject( CommandLine()->GetParm( 1 )) )
{
Msg( "Failed to parse project\n" );
return -1;
}
OutputKeyValuesVersion(proj);
CMakefileCreator makefile;
makefile.CreateMakefiles( proj );
return 0;
}
//-----------------------------------------------------------------------------
// 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;
}
//-----------------------------------------------------------------------------
// Tests the process.cpp stuff
//-----------------------------------------------------------------------------
int main( int argc, char **argv )
{
CommandLine()->CreateCmdLine( argc, argv );
InstallSpewFunction();
float flDelay = CommandLine()->ParmValue( "-delay", 0.0f );
const char *pEndMessage = CommandLine()->ParmValue( "-message", "Test Finished!\n" );
int nEndExtraBytes = CommandLine()->ParmValue( "-extrabytes", 0 );
if ( flDelay > 0.0f )
{
float t = Plat_FloatTime();
while ( Plat_FloatTime() - t < flDelay )
{
}
}
Msg( pEndMessage );
if ( nEndExtraBytes )
{
while( --nEndExtraBytes >= 0 )
{
Msg( "%c", ( nEndExtraBytes % 10 ) + '0' );
}
}
return 0;
}
// FIXME, this is BS
bool IsExternalBuild()
{
if ( CommandLine()->FindParm( "-publicbuild" ) )
{
return true;
}
if ( !CommandLine()->FindParm( "-internalbuild" ) &&
!CommandLine()->CheckParm("-dev") )
{
return true;
}
// It's an external build...
if ( m_bPhoneHome )
{
if ( !Q_stricmp( m_szBuildIdentifier, "beta-playtest" ) )
{
// Still internal
return false;
}
return true;
}
return false;
}
bool CTextConsoleUnix::Init( )
{
static struct termios termNew;
sigset_t block_ttou;
sigemptyset (&block_ttou);
sigaddset (&block_ttou, SIGTTOU);
sigprocmask (SIG_BLOCK, &block_ttou, NULL);
tty = stdout;
// this code is for echo-ing key presses to the connected tty
// (which is != STDOUT)
if ( isatty(STDIN_FILENO) )
{
tty = fopen( ctermid( NULL ), "w+" );
if ( !tty )
{
printf("Unable to open tty(%s) for output\n", ctermid( NULL ) );
tty = stdout;
}
else
{
setbuf( tty, NULL ); // turn buffering off
}
}
else
{
tty = fopen( "/dev/null", "w+" );
if ( !tty )
{
tty = stdout;
}
}
tcgetattr( STDIN_FILENO, &termStored );
memcpy( &termNew, &termStored, sizeof( struct termios ) );
/* Disable canonical mode, and set buffer size to 1 byte */
termNew.c_lflag &= ( ~ICANON );
termNew.c_cc[ VMIN ] = 1;
termNew.c_cc[ VTIME ] = 0;
/* disable echo */
termNew.c_lflag &= ( ~ECHO );
tcsetattr( STDIN_FILENO, TCSANOW, &termNew );
sigprocmask (SIG_UNBLOCK, &block_ttou, NULL);
m_bConDebug = CommandLine()->FindParm( "-condebug" ) != 0;
if ( m_bConDebug && CommandLine()->FindParm( "-conclearlog" ) )
{
g_pFullFileSystem->RemoveFile( CONSOLE_LOG_FILE, "GAME" );
}
return CTextConsole::Init();
}
virtual void Message( byte msgtype, char const *mapname )
{
if ( !m_bPhoneHome )
return;
if ( !m_pSocket )
return;
switch ( msgtype )
{
default:
break;
case PHONE_MSG_ENGINESTART:
if ( !RequestSessionId( m_uSessionID ) )
{
ExitApp();
}
// Note we always return here!!!
return;
case PHONE_MSG_ENGINEEND:
break;
case PHONE_MSG_MAPSTART:
{
if ( m_bLevelStarted )
{
return;
}
m_bLevelStarted = true;
// Tracker 22394: Don't send map start/finish when building reslists...
if ( CommandLine()->FindParm( "-makereslists" ) )
{
return;
}
}
break;
case PHONE_MSG_MAPEND:
{
if ( !m_bLevelStarted )
{
return;
}
m_bLevelStarted = false;
// Tracker 22394: Don't send map start/finish when building reslists...
if ( CommandLine()->FindParm( "-makereslists" ) )
{
return;
}
}
break;
}
SendSessionMessage( msgtype, mapname );
}
static CommandLine get_variant_object( const QVariantMap& m )
{
QString command = CalamaresUtils::getString( m, "command" );
int timeout = CalamaresUtils::getInteger( m, "timeout", CommandLine::TimeoutNotSet );
if ( !command.isEmpty() )
return CommandLine( command, timeout );
cWarning() << "Bad CommandLine element" << m;
return CommandLine();
}
//-----------------------------------------------------------------------------
// Purpose: One-time initialization
//-----------------------------------------------------------------------------
void CInput::Init_Mouse (void)
{
if ( CommandLine()->FindParm("-nomouse" ) )
return;
m_flPreviousMouseXPosition = 0.0f;
m_flPreviousMouseYPosition = 0.0f;
m_fMouseInitialized = true;
m_fMouseParmsValid = false;
if ( CommandLine()->FindParm ("-useforcedmparms" ) )
{
#ifdef WIN32
m_fMouseParmsValid = SystemParametersInfo( SPI_GETMOUSE, 0, m_rgOrigMouseParms, 0 ) ? true : false;
#else
m_fMouseParmsValid = false;
#endif
if ( m_fMouseParmsValid )
{
if ( CommandLine()->FindParm ("-noforcemspd" ) )
{
m_rgNewMouseParms[ MOUSE_SPEED_FACTOR ] = m_rgOrigMouseParms[ MOUSE_SPEED_FACTOR ];
/*
int mouseAccel[3];
SystemParametersInfo(SPI_GETMOUSE, 0, &mouseAccel, 0); mouseAccel[2] = 0;
bool ok = SystemParametersInfo(SPI_SETMOUSE, 0, &mouseAccel, SPIF_UPDATEINIFILE);
// Now check registry and close/re-open Control Panel > Mouse and see 'Enhance pointer precision' is OFF
mouseAccel[2] = 1;
ok = SystemParametersInfo(SPI_SETMOUSE, 0, &mouseAccel, SPIF_UPDATEINIFILE);
// Now check registry and close/re-open Control Panel > Mouse and see 'Enhance pointer precision' is ON
*/
}
else
{
m_rgCheckMouseParam[ MOUSE_SPEED_FACTOR ] = 1;
}
if ( CommandLine()->FindParm ("-noforcemaccel" ) )
{
m_rgNewMouseParms[ MOUSE_ACCEL_THRESHHOLD1 ] = m_rgOrigMouseParms[ MOUSE_ACCEL_THRESHHOLD1 ];
m_rgNewMouseParms[ MOUSE_ACCEL_THRESHHOLD2 ] = m_rgOrigMouseParms[ MOUSE_ACCEL_THRESHHOLD2 ];
}
else
{
m_rgCheckMouseParam[ MOUSE_ACCEL_THRESHHOLD1 ] = true;
m_rgCheckMouseParam[ MOUSE_ACCEL_THRESHHOLD2 ] = true;
}
}
}
}
// app started, must check for update/install requests
// returns true if app must continue execution, false otherwise
bool Updater::DO_NormalRun(void)
{
// we now check if we just want to uninstall app
// it can be done by command line --UNINSTALL option
if(CommandLine().GetCount() && CommandLine()[0] == "--UNINSTALL")
return START_Uninstall();
// if app not installed, we shall install it
// (if any available version is present on server....)
if(!appInstalled)
{
// fetch available application versions
ProductVersions versions = FetchVersions();
// if versions present on server, install latest
if(versions.GetCount())
return START_Install();
// otherwise resume execution -- it's an uninstalled run
else
return true;
}
// not installing nor uninstalling
// we shall check which kind of update is enabled
String updateMode;
if(!FileExists(AppendFileName(userConfigPath, "UPDATER_MODE")))
{
updateMode = "ASK";
SaveFile(AppendFileName(userConfigPath, "UPDATER_MODE"), updateMode);
}
else
updateMode = LoadFile(AppendFileName(userConfigPath, "UPDATER_MODE"));
// if updates are disabled, just do nothing
if(updateMode == "DISABLED")
return true;
// if we don't have a new version available, just do nothing
ProductVersion maxVer;
if( (maxVer = FetchMaxValidVersion(acceptDevelVersions)) <= installedVersion)
return true;
// if we want manual updates, just ask
if(updateMode == "ASK")
if(!PromptYesNo(Format(t_("New version '%s' is available&Install it ?"), maxVer.ToString())))
return true;
// updater enabled, start it
// if update failed, resume normal run, otherwise exit
// as the app will be launched again by updater itself
return START_Update();
}
//-----------------------------------------------------------------------------
// Create all singleton systems
//-----------------------------------------------------------------------------
bool CHLModelViewerApp::Create()
{
SpewOutputFunc( HLMVSpewFunc );
g_dxlevel = CommandLine()->ParmValue( "-dx", 0 );
g_bOldFileDialogs = ( CommandLine()->FindParm( "-olddialogs" ) != 0 );
AppSystemInfo_t appSystems[] =
{
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
{ "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION },
{ "vphysics.dll", VPHYSICS_INTERFACE_VERSION },
{ "datacache.dll", DATACACHE_INTERFACE_VERSION },
{ "datacache.dll", MDLCACHE_INTERFACE_VERSION },
{ "datacache.dll", STUDIO_DATA_CACHE_INTERFACE_VERSION },
{ "soundemittersystem.dll", SOUNDEMITTERSYSTEM_INTERFACE_VERSION },
{ "soundsystem.dll", SOUNDSYSTEM_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
if ( !AddSystems( appSystems ) )
return false;
g_pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION );
g_pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
g_pMaterialSystemHardwareConfig = (IMaterialSystemHardwareConfig*)FindSystem( MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION );
g_pStudioRender = (IStudioRender*)FindSystem( STUDIO_RENDER_INTERFACE_VERSION );
g_pDataCache = (IDataCache*)FindSystem( DATACACHE_INTERFACE_VERSION );
g_pMDLCache = (IMDLCache*)FindSystem( MDLCACHE_INTERFACE_VERSION );
g_pStudioDataCache = (IStudioDataCache*)FindSystem( STUDIO_DATA_CACHE_INTERFACE_VERSION );
physcollision = (IPhysicsCollision *)FindSystem( VPHYSICS_COLLISION_INTERFACE_VERSION );
physprop = (IPhysicsSurfaceProps *)FindSystem( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION );
g_pSoundEmitterBase = (ISoundEmitterSystemBase *)FindSystem( SOUNDEMITTERSYSTEM_INTERFACE_VERSION );
g_pSoundSystem = (ISoundSystem *)FindSystem( SOUNDSYSTEM_INTERFACE_VERSION );
if ( !g_pFileSystem || !physprop || !physcollision || !g_pMaterialSystem || !g_pStudioRender || !g_pMDLCache || !g_pDataCache )
{
Error("Unable to load required library interface!\n");
}
const char *pShaderDLL = CommandLine()->ParmValue("-shaderdll");
if(!pShaderDLL)
{
pShaderDLL = "shaderapidx9.dll";
}
g_pMaterialSystem->SetShaderAPI( pShaderDLL );
g_Factory = GetFactory();
return true;
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
int CPCFFixApp::Main()
{
g_pDataModel->SetUndoEnabled( false );
g_pDataModel->OnlyCreateUntypedElements( true );
g_pDataModel->SetDefaultElementFactory( NULL );
// This bit of hackery allows us to access files on the harddrive
g_pFullFileSystem->AddSearchPath( "", "LOCAL", PATH_ADD_TO_HEAD );
if ( CommandLine()->CheckParm( "-h" ) || CommandLine()->CheckParm( "-help" ) )
{
PrintHelp();
return 0;
}
// Do Perforce Stuff
if ( CommandLine()->FindParm( "-nop4" ) )
{
g_p4factory->SetDummyMode( true );
}
g_p4factory->SetOpenFileChangeList( "Fixed PCF files" );
const char *pPCFFile = CommandLine()->ParmValue( "-i" );
if ( !pPCFFile )
{
PrintHelp();
return 0;
}
CDmElement *pRoot;
if ( g_pDataModel->RestoreFromFile( pPCFFile, NULL, "pcf", &pRoot, CR_DELETE_NEW ) == DMFILEID_INVALID )
{
Error( "Encountered an error reading file \"%s\"!\n", pPCFFile );
return -1;
}
FixupPCFFile( pRoot );
CP4AutoEditFile checkout( pPCFFile );
const char *pOutEncoding = g_pDataModel->GetDefaultEncoding( "pcf" );
if ( !g_pDataModel->SaveToFile( pPCFFile, NULL, pOutEncoding, "pcf", pRoot ) )
{
Error( "Encountered an error writing file \"%s\"!\n", pPCFFile );
return -1;
}
g_pDataModel->RemoveFileId( pRoot->GetFileId() );
return -1;
}
//-----------------------------------------------------------------------------
// main application
//-----------------------------------------------------------------------------
int CHLModelViewerApp::Main()
{
g_pMaterialSystem->ModInit();
g_pSoundEmitterBase->ModInit();
g_pDataCache->SetSize( 64 * 1024 * 1024 );
//mx::setDisplayMode (0, 0, 0);
g_MDLViewer = new MDLViewer ();
g_MDLViewer->setMenuBar (g_MDLViewer->getMenuBar ());
g_pStudioModel->Init();
g_pStudioModel->ModelInit();
g_pStudioModel->ClearLookTargets( );
// Load up the initial model
const char *pMdlName = NULL;
int nParmCount = CommandLine()->ParmCount();
if ( nParmCount > 1 )
{
pMdlName = CommandLine()->GetParm( nParmCount - 1 );
}
if ( pMdlName && Q_stristr( pMdlName, ".mdl" ) )
{
char absPath[MAX_PATH];
Q_MakeAbsolutePath( absPath, sizeof( absPath ), pMdlName );
if ( CommandLine()->FindParm( "-screenshot" ) )
{
g_MDLViewer->SaveScreenShot( absPath );
}
else if ( CommandLine()->FindParm( "-dump" ) )
{
g_MDLViewer->DumpText( absPath );
}
else
{
g_MDLViewer->LoadModelFile( absPath );
}
}
int nRetVal = mx::run ();
g_pStudioModel->Shutdown();
g_pMaterialSystem->ModShutdown();
return nRetVal;
}
bool FileSystem_GetExecutableDir( char *exedir, int exeDirLen )
{
exedir[0] = 0;
if ( s_bUseVProjectBinDir )
{
const char *pProject = GetVProjectCmdLineValue();
if ( !pProject )
{
// Check their registry.
pProject = getenv( GAMEDIR_TOKEN );
}
if ( pProject )
{
Q_snprintf( exedir, exeDirLen, "%s%c..%cbin", pProject, CORRECT_PATH_SEPARATOR, CORRECT_PATH_SEPARATOR );
return true;
}
return false;
}
if ( !Sys_GetExecutableName( exedir, exeDirLen ) )
return false;
Q_StripFilename( exedir );
if ( IsX360() )
{
// The 360 can have its exe and dlls reside on different volumes
// use the optional basedir as the exe dir
if ( CommandLine()->FindParm( "-basedir" ) )
{
strcpy( exedir, CommandLine()->ParmValue( "-basedir", "" ) );
}
}
Q_FixSlashes( exedir );
// Return the bin directory as the executable dir if it's not in there
// because that's really where we're running from...
char ext[MAX_PATH];
Q_StrRight( exedir, 4, ext, sizeof( ext ) );
if ( ext[0] != CORRECT_PATH_SEPARATOR || Q_stricmp( ext+1, "bin" ) != 0 )
{
Q_strncat( exedir, CORRECT_PATH_SEPARATOR_S, exeDirLen, COPY_ALL_CHARACTERS );
Q_strncat( exedir, "bin", exeDirLen, COPY_ALL_CHARACTERS );
Q_FixSlashes( exedir );
}
return true;
}
void InitCommandLineProgram( int argc, char **argv )
{
MathLib_Init( 1,1,1,0,false,true,true,true);
CommandLine()->CreateCmdLine( argc, argv );
InitDefaultFileSystem();
InstallProgressReportHandler( PrintFReportHandler );
}
bool SendTable_Init( SendTable **pTables, int nTables )
{
ErrorIfNot( g_SendTables.Count() == 0,
("SendTable_Init: called twice.")
);
// Initialize them all.
for ( int i=0; i < nTables; i++ )
{
if ( !SendTable_InitTable( pTables[i] ) )
return false;
}
// Store off the SendTable list.
g_SendTables.CopyArray( pTables, nTables );
g_SendTableCRC = SendTable_ComputeCRC( );
if ( CommandLine()->FindParm("-dti" ) )
{
SendTable_PrintStats();
}
return true;
}
//-----------------------------------------------------------------------------
// XBX_InitConsoleMonitor
//
//-----------------------------------------------------------------------------
void CXboxConsole::InitConsoleMonitor( bool bWaitForConnect )
{
if ( XBX_NoXBDM() )
return;
// create our events
g_xbx_dbgValidEvent = CreateEvent( XBOX_DONTCARE, TRUE, FALSE, NULL );
g_xbx_dbgCmdCompleteEvent = CreateEvent( XBOX_DONTCARE, FALSE, FALSE, NULL );
// register our command handler with the debug monitor
HRESULT hr = DmRegisterCommandProcessor( XBX_DBGCOMMANDPREFIX, _DebugCommandHandler );
if ( FAILED( hr ) )
{
XBX_Error( "XBX_InitConsoleMonitor: failed to register command processor" );
}
// user can have output bypass slave thread
g_xbx_bDoSyncOutput = CommandLine()->FindParm( "-syncoutput" ) != 0;
// create a slave thread to do delayed VXConsole transactions
ThreadId_t threadID;
g_xbx_hDebugThread = CreateSimpleThread( _DebugThreadFunc, NULL, &threadID, 16*1024 );
ThreadSetDebugName( threadID, "DebugThread" );
ThreadSetAffinity( g_xbx_hDebugThread, XBOX_PROCESSOR_5 );
if ( bWaitForConnect )
{
XBX_DebugString( XBX_CLR_DEFAULT, "Waiting For VXConsole Connection...\n" );
WaitForSingleObject( g_xbx_dbgValidEvent, INFINITE );
}
}
bool FileSystem_Init( const char *pBSPFilename, int maxMemoryUsage, FSInitType_t initType, bool bOnlyUseFilename )
{
Assert( CommandLine()->GetCmdLine() != NULL ); // Should have called CreateCmdLine by now.
// If this app uses VMPI, then let VMPI intercept all filesystem calls.
#if defined( MPI )
if ( g_bUseMPI )
{
if ( g_bMPIMaster )
{
if ( !FileSystem_Init_Normal( pBSPFilename, initType, bOnlyUseFilename ) )
return false;
g_pFileSystem = g_pFullFileSystem = VMPI_FileSystem_Init( maxMemoryUsage, g_pFullFileSystem );
SendQDirInfo();
}
else
{
g_pFileSystem = g_pFullFileSystem = VMPI_FileSystem_Init( maxMemoryUsage, NULL );
RecvQDirInfo();
}
return true;
}
#endif
return FileSystem_Init_Normal( pBSPFilename, initType, bOnlyUseFilename );
}
void CBaseGameStats_Driver::SendData()
{
// if we don't own the data container or there's no valid data, nothing to do
if ( !m_pGamestatsData || !m_pGamestatsData->m_bHaveData )
return;
// save the data to a buffer
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
m_pGamestatsData->m_pKVData->RecursiveSaveToFile( buf, 0 );
if ( CommandLine()->FindParm( "-gamestatsfileoutputonly" ) )
{
// write file for debugging
const char szFileName[] = "gamestats.dat";
filesystem->WriteFile( szFileName, GAMESTATS_PATHID, buf );
}
else
{
// upload the file to Steam
if ( gamestatsuploader )
gamestatsuploader->UploadGameStats( "", 1, buf.TellPut(), buf.Base() );
}
ResetData();
}
static void FileSystem_AddLoadedSearchPath(
CFSSearchPathsInit &initInfo,
const char *pPathID,
const char *fullLocationPath,
bool bLowViolence )
{
// Check for mounting LV game content in LV builds only
if ( V_stricmp( pPathID, "game_lv" ) == 0 )
{
// Not in LV build, don't mount
if ( !initInfo.m_bLowViolence )
return;
// Mount, as a game path
pPathID = "game";
}
// Check for mounting HD game content if enabled
if ( V_stricmp( pPathID, "game_hd" ) == 0 )
{
// Not in LV build, don't mount
if ( !initInfo.m_bMountHDContent )
return;
// Mount, as a game path
pPathID = "game";
}
// Special processing for ordinary game folders
if ( V_stristr( fullLocationPath, ".vpk" ) == NULL && Q_stricmp( pPathID, "game" ) == 0 )
{
if ( CommandLine()->FindParm( "-tempcontent" ) != 0 )
{
char szPath[MAX_PATH];
Q_snprintf( szPath, sizeof(szPath), "%s_tempcontent", fullLocationPath );
initInfo.m_pFileSystem->AddSearchPath( szPath, pPathID, PATH_ADD_TO_TAIL );
}
}
if ( initInfo.m_pLanguage &&
Q_stricmp( initInfo.m_pLanguage, "english" ) &&
V_strstr( fullLocationPath, "_english" ) != NULL )
{
char szPath[MAX_PATH];
char szLangString[MAX_PATH];
// Need to add a language version of this path first
Q_snprintf( szLangString, sizeof(szLangString), "_%s", initInfo.m_pLanguage);
V_StrSubst( fullLocationPath, "_english", szLangString, szPath, sizeof( szPath ), true );
initInfo.m_pFileSystem->AddSearchPath( szPath, pPathID, PATH_ADD_TO_TAIL );
}
initInfo.m_pFileSystem->AddSearchPath( fullLocationPath, pPathID, PATH_ADD_TO_TAIL );
}
int main(int argc, char* argv[])
{
CommandLine()->CreateCmdLine( argc, argv );
const char *pDLLName = "vvis_dll.dll";
CSysModule *pModule = Sys_LoadModule( pDLLName );
if ( !pModule )
{
printf( "vvis launcher error: can't load %s\n%s", pDLLName, GetLastErrorString() );
return 1;
}
CreateInterfaceFn fn = Sys_GetFactory( pModule );
if( !fn )
{
printf( "vvis launcher error: can't get factory from %s\n", pDLLName );
Sys_UnloadModule( pModule );
return 2;
}
int retCode = 0;
ILaunchableDLL *pDLL = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, &retCode );
if( !pDLL )
{
printf( "vvis launcher error: can't get IVVisDLL interface from %s\n", pDLLName );
Sys_UnloadModule( pModule );
return 3;
}
pDLL->main( argc, argv );
Sys_UnloadModule( pModule );
return 0;
}
void RunInDLL( const char *pFilename, CUtlVector<char*> &newArgv )
{
if ( g_pConnMgr )
g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_BUSY );
bool bSuccess = false;
CSysModule *pModule = Sys_LoadModule( pFilename );
if ( pModule )
{
CreateInterfaceFn fn = Sys_GetFactory( pModule );
if ( fn )
{
ILaunchableDLL *pDLL = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, NULL );
if( pDLL )
{
// Do this here because the executables we would have launched usually would do it.
CommandLine()->CreateCmdLine( newArgv.Count(), newArgv.Base() );
pDLL->main( newArgv.Count(), newArgv.Base() );
bSuccess = true;
SpewOutputFunc( MySpewOutputFunc );
}
}
Sys_UnloadModule( pModule );
}
if ( !bSuccess )
{
Msg( "Error running VRAD (or VVIS) out of DLL '%s'\n", pFilename );
}
if ( g_pConnMgr )
g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_IDLE );
}
void CGameUI2::Initialize(CreateInterfaceFn appFactory)
{
MEM_ALLOC_CREDIT();
ConnectTier1Libraries(&appFactory, 1);
ConnectTier2Libraries(&appFactory, 1);
ConVar_Register(FCVAR_CLIENTDLL);
ConnectTier3Libraries(&appFactory, 1);
engine = static_cast<IVEngineClient*>(appFactory(VENGINE_CLIENT_INTERFACE_VERSION, nullptr));
enginesound = static_cast<IEngineSound*>(appFactory(IENGINESOUND_CLIENT_INTERFACE_VERSION, nullptr));
enginevgui = static_cast<IEngineVGui*>(appFactory(VENGINE_VGUI_VERSION, nullptr));
soundemitterbase = static_cast<ISoundEmitterSystemBase*>(appFactory(SOUNDEMITTERSYSTEM_INTERFACE_VERSION, nullptr));
render = static_cast<IVRenderView*>(appFactory(VENGINE_RENDERVIEW_INTERFACE_VERSION, nullptr));
CreateInterfaceFn gameUIFactory = g_GameUI.GetFactory();
if (gameUIFactory)
gameui = static_cast<IGameUI*>(gameUIFactory(GAMEUI_INTERFACE_VERSION, nullptr));
if (!enginesound || !enginevgui || !engine || !soundemitterbase || !render || !gameui)
Error("CGameUI2::Initialize() failed to get necessary interfaces.\n");
if (!CommandLine()->FindParm("-shaderedit"))
{
GetBasePanel()->Create();
if (GetBasePanel())
gameui->SetMainMenuOverride(GetBasePanel()->GetMainMenu()->GetVPanel());
}
}
//-----------------------------------------------------------------------------
// Purpose: One-time initialization
//-----------------------------------------------------------------------------
void CInput::Init_Mouse (void)
{
if ( CommandLine()->FindParm("-nomouse" ) )
return;
for ( int hh = 0; hh < MAX_SPLITSCREEN_PLAYERS; ++hh )
{
ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh );
GetPerUser().m_flPreviousMouseXPosition = 0.0f;
GetPerUser().m_flPreviousMouseYPosition = 0.0f;
}
m_fMouseInitialized = true;
m_fMouseParmsValid = false;
if ( CommandLine()->FindParm ("-useforcedmparms" ) )
{
#ifdef WIN32
m_fMouseParmsValid = SystemParametersInfo( SPI_GETMOUSE, 0, m_rgOrigMouseParms, 0 ) ? true : false;
#else
m_fMouseParmsValid = false;
#endif
if ( m_fMouseParmsValid )
{
if ( CommandLine()->FindParm ("-noforcemspd" ) )
{
m_rgNewMouseParms[ MOUSE_SPEED_FACTOR ] = m_rgOrigMouseParms[ MOUSE_SPEED_FACTOR ];
}
else
{
m_rgCheckMouseParam[ MOUSE_SPEED_FACTOR ] = true;
}
if ( CommandLine()->FindParm ("-noforcemaccel" ) )
{
m_rgNewMouseParms[ MOUSE_ACCEL_THRESHHOLD1 ] = m_rgOrigMouseParms[ MOUSE_ACCEL_THRESHHOLD1 ];
m_rgNewMouseParms[ MOUSE_ACCEL_THRESHHOLD2 ] = m_rgOrigMouseParms[ MOUSE_ACCEL_THRESHHOLD2 ];
}
else
{
m_rgCheckMouseParam[ MOUSE_ACCEL_THRESHHOLD1 ] = true;
m_rgCheckMouseParam[ MOUSE_ACCEL_THRESHHOLD2 ] = true;
}
}
}
}