451 lines
14 KiB
C++
451 lines
14 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// The copyright to the contents herein is the property of Valve, L.L.C.
|
|
// The contents may be used and/or copied only with the written permission of
|
|
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
|
// the agreement/contract under which the contents have been supplied.
|
|
//
|
|
// $Header: $
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
// NOTE: We specifically don't want to include *any* valve libraries
|
|
// because this is expected to be run on a customer's machine and we
|
|
// don't want to have to deal with any strange path stuff
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Print help
|
|
//-----------------------------------------------------------------------------
|
|
void PrintHelp( )
|
|
{
|
|
printf( "Usage: rpt -i <in .csv file> -m <.mdl relative path> -o <output dir>\n" );
|
|
printf( " [-f <fac output dir>] [-p] [-w] [-r <sample rate in hz>] [-s <sample filter size>]\n" );
|
|
printf( " [-nop4] [-vproject <path to gameinfo.txt>]\n" );
|
|
printf( "\t-h,-help,-?\t:Displays this help message.\n" );
|
|
printf( "\t-m\t: Indicates the path of the .mdl file under game/mod/models/ to use in the sfm files.\n" );
|
|
printf( "\t-o\t: Indicates output directory to place generated files in.\n" );
|
|
printf( "\t-f\t: [Optional] Indicates that facial files should be created in the specified fac output dir.\n" );
|
|
printf( "\t-p\t: [Optional] Indicates the extracted phonemes should be written into the wav file.\n" );
|
|
printf( "\t-w\t: [Optional] Indicates the phonemes should be read from the wav file. Cannot also have -p specified.\n" );
|
|
printf( "\t-r\t: [Optional] Specifies the phoneme extraction sample rate (default = 20)\n" );
|
|
printf( "\t-s\t: [Optional] Specifies the phoneme extraction sample filter size (default = 0.08)\n" );
|
|
printf( "\t-nop4\t: Disables auto perforce checkout/add.\n" );
|
|
printf( "\t-vproject\t: Specifies path to a gameinfo.txt file (which mod to build for).\n" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used to parse the commandline
|
|
//-----------------------------------------------------------------------------
|
|
static int FindParm( const char *pParam, int argc, char **argv )
|
|
{
|
|
// Start at 1 so as to not search the exe name
|
|
for ( int i = 1; i < argc; ++i )
|
|
{
|
|
if ( !strcmp( pParam, argv[i] ) )
|
|
return i;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Strips the last file from a filename, returns int offset of string end
|
|
//-----------------------------------------------------------------------------
|
|
static size_t StripFileName( char *pFileName )
|
|
{
|
|
// In this case, we queried the key properly. Strip off the steamclient.dll name
|
|
// to make a good full path to steam.exe
|
|
char *pSlash = strrchr( pFileName, '\\' );
|
|
char *pSlash2 = strrchr( pFileName, '/' );
|
|
if ( pSlash2 > pSlash )
|
|
{
|
|
pSlash = pSlash2;
|
|
}
|
|
if ( !pSlash )
|
|
{
|
|
pSlash = pFileName;
|
|
}
|
|
else
|
|
{
|
|
++pSlash;
|
|
}
|
|
*pSlash = 0;
|
|
size_t nLen = (size_t)pSlash - (size_t)pFileName;
|
|
return nLen;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used to detect where steam is running from
|
|
//-----------------------------------------------------------------------------
|
|
static DWORD GetActiveSteamPID( )
|
|
{
|
|
HKEY hKey;
|
|
LONG hResult = RegOpenKey( HKEY_CURRENT_USER, "Software\\Valve\\Steam\\ActiveProcess", &hKey );
|
|
if ( hResult != ERROR_SUCCESS )
|
|
return 0;
|
|
|
|
DWORD nType;
|
|
char pTempBuf[256];
|
|
DWORD nLen = sizeof(pTempBuf);
|
|
hResult = RegQueryValueEx( hKey, "pid", NULL, &nType, (unsigned char *)pTempBuf, &nLen );
|
|
RegCloseKey( hKey );
|
|
if ( hResult != ERROR_SUCCESS || nLen == 0 )
|
|
return 0;
|
|
|
|
switch( nType )
|
|
{
|
|
case REG_DWORD:
|
|
return *(DWORD*)pTempBuf;
|
|
|
|
case REG_QWORD:
|
|
return (DWORD)( *(__int64*)pTempBuf );
|
|
|
|
case REG_SZ:
|
|
case REG_EXPAND_SZ:
|
|
return atoi( pTempBuf );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used to detect where steam is running from
|
|
//-----------------------------------------------------------------------------
|
|
static bool DetectSteamPath( char *pFileName, int nBufLen )
|
|
{
|
|
*pFileName = 0;
|
|
|
|
DWORD nLen;
|
|
|
|
// First check to see if there's an active process
|
|
HKEY hKey;
|
|
LONG hResult = RegOpenKey( HKEY_CURRENT_USER, "Software\\Valve\\Steam\\ActiveProcess", &hKey );
|
|
if ( hResult == ERROR_SUCCESS )
|
|
{
|
|
nLen = (DWORD)nBufLen;
|
|
hResult = RegQueryValueEx( hKey, "SteamClientDll", NULL, NULL, (LPBYTE)pFileName, &nLen );
|
|
RegCloseKey( hKey );
|
|
if ( hResult == ERROR_SUCCESS )
|
|
{
|
|
// In this case, we queried the key properly. Strip off the steamclient.dll name
|
|
// to make a good full path to steam.exe
|
|
size_t nUsed = StripFileName( pFileName );
|
|
strncpy( &pFileName[nUsed], "steam.exe", nBufLen - nUsed );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// If not, then get the default install location
|
|
hResult = RegOpenKey( HKEY_CURRENT_USER, "Software\\Valve\\Steam", &hKey );
|
|
if ( hResult != ERROR_SUCCESS )
|
|
return false;
|
|
|
|
nLen = (DWORD)nBufLen;
|
|
hResult = RegQueryValueEx( hKey, "SteamExe", NULL, NULL, (LPBYTE)pFileName, &nLen );
|
|
RegCloseKey( hKey );
|
|
return ( hResult == ERROR_SUCCESS && nLen != 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Displays a windows error
|
|
//-----------------------------------------------------------------------------
|
|
static void DisplayWindowsError( const char *pMessage )
|
|
{
|
|
DWORD dw = GetLastError();
|
|
char pErrorMessage[2048];
|
|
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
pErrorMessage, sizeof(pErrorMessage), NULL );
|
|
printf( "%s\n%s\n", pMessage, pErrorMessage );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Deletes steam.cfg
|
|
//-----------------------------------------------------------------------------
|
|
static void DeleteCfgFile( const char *pFullPath )
|
|
{
|
|
remove( pFullPath );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Launches steam.exe, returns process ID (0 if failed)
|
|
//-----------------------------------------------------------------------------
|
|
static DWORD LaunchSteam( const char *pFullPath, const char *pArgs )
|
|
{
|
|
// Try to launch steam, shutting down any existing instance.
|
|
STARTUPINFO si;
|
|
memset( &si, 0, sizeof si );
|
|
si.cb = sizeof(si);
|
|
|
|
PROCESS_INFORMATION pi;
|
|
if ( !CreateProcess( pFullPath, (char*)pArgs, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, NULL, &si, &pi ) )
|
|
return 0;
|
|
|
|
return pi.dwProcessId;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is process active?
|
|
//-----------------------------------------------------------------------------
|
|
static bool IsSteamProcessActive( DWORD nProcessID )
|
|
{
|
|
if ( nProcessID == 0 )
|
|
return false;
|
|
|
|
HANDLE hProcess = OpenProcess( PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION, FALSE, nProcessID );
|
|
bool bProcessActive = ( hProcess != 0 );
|
|
if ( bProcessActive )
|
|
{
|
|
DWORD nExitCode;
|
|
BOOL bOk = GetExitCodeProcess( hProcess, &nExitCode );
|
|
if ( !bOk || ( nExitCode != STILL_ACTIVE ) )
|
|
{
|
|
bProcessActive = false;
|
|
}
|
|
}
|
|
|
|
CloseHandle( hProcess );
|
|
return bProcessActive;
|
|
}
|
|
|
|
|
|
static void TerminateSteamProcess( DWORD nProcessID )
|
|
{
|
|
if ( nProcessID == 0 )
|
|
return;
|
|
|
|
HANDLE hProcess = OpenProcess( PROCESS_TERMINATE, FALSE, nProcessID );
|
|
if ( hProcess != 0 )
|
|
{
|
|
TerminateProcess( hProcess, 0 );
|
|
CloseHandle( hProcess );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Shuts down existing steam process
|
|
//-----------------------------------------------------------------------------
|
|
static bool ShutdownExistingSteamProcess( const char *pSteamPath )
|
|
{
|
|
DWORD nSteamPID = GetActiveSteamPID( );
|
|
|
|
// Ensure the process is actually running.
|
|
// The registry simply stores the last run steam process id
|
|
if ( !IsSteamProcessActive( nSteamPID ) )
|
|
{
|
|
nSteamPID = 0;
|
|
}
|
|
|
|
// Try to shut down existing instances of steam
|
|
if ( nSteamPID == 0 )
|
|
return true;
|
|
|
|
if ( !LaunchSteam( pSteamPath, "-shutdown" ) )
|
|
{
|
|
DisplayWindowsError( "rpt: Unable to shutdown existing steam process!" );
|
|
return false;
|
|
}
|
|
|
|
// Wait for the old process to terminate
|
|
// Wait for at least 30 seconds. If it doesn't start by that time,
|
|
// then kill the existing process.
|
|
DWORD nStartTime = GetTickCount();
|
|
DWORD nTestTime = 30;
|
|
while ( IsSteamProcessActive( nSteamPID ) )
|
|
{
|
|
Sleep( 1000 );
|
|
DWORD dt = ( GetTickCount() - nStartTime ) / 1000;
|
|
if ( dt <= nTestTime )
|
|
continue;
|
|
|
|
TerminateSteamProcess( nSteamPID );
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copies test files into position
|
|
//-----------------------------------------------------------------------------
|
|
bool CopyFilesRecursively( const char *pSrcPath, const char *pDestPath )
|
|
{
|
|
// Create a file that makes steam not delete different DLLs
|
|
char pSearchStr[MAX_PATH];
|
|
_snprintf( pSearchStr, sizeof(pSearchStr), "%s*", pSrcPath );
|
|
|
|
WIN32_FIND_DATA find;
|
|
HANDLE hFind = FindFirstFile( pSearchStr, &find );
|
|
if( INVALID_HANDLE_VALUE == hFind )
|
|
return true;
|
|
|
|
// Make sure the dest path exists
|
|
if ( ( GetFileAttributes( pDestPath ) & FILE_ATTRIBUTE_DIRECTORY ) == 0 )
|
|
{
|
|
if ( !CreateDirectory( pDestPath, NULL ) )
|
|
{
|
|
printf( "Unable to create directory %s\n", pDestPath );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Display each file and ask for the next.
|
|
do
|
|
{
|
|
// Skip . and ..
|
|
if ( !strcmp( find.cFileName, "." ) || !strcmp( find.cFileName, ".." ) )
|
|
continue;
|
|
|
|
char pSrcChildPath[MAX_PATH];
|
|
char pDestChildPath[MAX_PATH];
|
|
|
|
// Deal with directories
|
|
if ( ( find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) && ( ( find.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) == 0 ) )
|
|
{
|
|
_snprintf( pSrcChildPath, sizeof(pSrcChildPath), "%s%s\\", pSrcPath, find.cFileName );
|
|
_snprintf( pDestChildPath, sizeof(pDestChildPath), "%s%s\\", pDestPath, find.cFileName );
|
|
if ( !CopyFilesRecursively( pSrcChildPath, pDestChildPath ) )
|
|
return false;
|
|
continue;
|
|
}
|
|
|
|
_snprintf( pSrcChildPath, sizeof(pSrcChildPath), "%s%s", pSrcPath, find.cFileName );
|
|
_snprintf( pDestChildPath, sizeof(pDestChildPath), "%s%s", pDestPath, find.cFileName );
|
|
|
|
// Copy everything else
|
|
// NOTE: This may fail if the file isn't already there
|
|
SetFileAttributes( pDestChildPath, FILE_ATTRIBUTE_NORMAL );
|
|
|
|
if ( CopyFile( pSrcChildPath, pDestChildPath, FALSE ) == 0 )
|
|
{
|
|
printf( "Unable to copy file %s to %s\n", pSrcChildPath, pDestChildPath );
|
|
return false;
|
|
}
|
|
|
|
if ( !SetFileAttributes( pDestChildPath, FILE_ATTRIBUTE_READONLY ) )
|
|
{
|
|
printf( "Unable to make file %s read only.\n", pDestChildPath );
|
|
return false;
|
|
}
|
|
|
|
} while( FindNextFile( hFind, &find ) );
|
|
|
|
// Close the find handle.
|
|
FindClose( hFind );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copies test files into position
|
|
//-----------------------------------------------------------------------------
|
|
static bool CopyFilesIntoPosition( const char *pSteamPath )
|
|
{
|
|
// Create a file that makes steam not delete different DLLs
|
|
char pSteamRoot[MAX_PATH];
|
|
strncpy( pSteamRoot, pSteamPath, sizeof(pSteamRoot) );
|
|
StripFileName( pSteamRoot );
|
|
|
|
char pSrcRoot[MAX_PATH];
|
|
if ( !::GetModuleFileName( ( HINSTANCE )GetModuleHandle( NULL ), pSrcRoot, sizeof(pSrcRoot) ) )
|
|
{
|
|
printf( "Unable to find rpt launch path!\n" );
|
|
return false;
|
|
}
|
|
StripFileName( pSrcRoot );
|
|
|
|
return CopyFilesRecursively( pSrcRoot, pSteamRoot );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Launches new steam process
|
|
//-----------------------------------------------------------------------------
|
|
static bool LaunchNewSteamProcess( const char *pSteamPath )
|
|
{
|
|
// Create a file that makes steam not delete different DLLs
|
|
char pCfgPath[MAX_PATH];
|
|
strncpy( pCfgPath, pSteamPath, sizeof(pCfgPath) );
|
|
size_t nUsed = StripFileName( pCfgPath );
|
|
strncpy( &pCfgPath[nUsed], "steam.cfg", sizeof(pCfgPath) - nUsed );
|
|
|
|
FILE* fp = fopen( pCfgPath, "wt" );
|
|
if ( !fp )
|
|
{
|
|
printf( "rpt: Unable to relaunch steam! Aborting...\n" );
|
|
return false;
|
|
}
|
|
|
|
fprintf( fp, "MinFootprintAutoRefresh = disable\n" );
|
|
fclose( fp );
|
|
|
|
// Launch a new instance of steam
|
|
DWORD nNewPID = LaunchSteam( pSteamPath, "" );
|
|
|
|
// Wait for the new process to start.
|
|
// Wait for at least 30 seconds. If it doesn't start by that time,
|
|
// stop what we're doing.
|
|
DWORD nStartTime = GetTickCount();
|
|
DWORD nTestTime = 30;
|
|
while ( GetActiveSteamPID( ) != nNewPID )
|
|
{
|
|
Sleep( 1000 );
|
|
DWORD dt = ( GetTickCount() - nStartTime ) / 1000;
|
|
if ( dt <= nTestTime )
|
|
continue;
|
|
|
|
TerminateSteamProcess( nNewPID );
|
|
DeleteCfgFile( pCfgPath );
|
|
printf( "rpt: Unable to launch new steam process!" );
|
|
return false;
|
|
}
|
|
|
|
DeleteCfgFile( pCfgPath );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The application object
|
|
//-----------------------------------------------------------------------------
|
|
int main( int argc, char **argv )
|
|
{
|
|
if ( FindParm( "-h", argc, argv ) || FindParm( "-help", argc, argv ) || FindParm( "-?", argc, argv ) )
|
|
{
|
|
PrintHelp();
|
|
return 0;
|
|
}
|
|
|
|
// Detect the currently running version of steam
|
|
char pSteamPath[MAX_PATH];
|
|
if ( !DetectSteamPath( pSteamPath, sizeof(pSteamPath) ) )
|
|
{
|
|
printf( "rpt: Unable to detect steam installation path! Aborting...\n" );
|
|
return 0;
|
|
}
|
|
|
|
if ( !ShutdownExistingSteamProcess( pSteamPath ) )
|
|
return 0;
|
|
|
|
if ( !CopyFilesIntoPosition( pSteamPath ) )
|
|
return 0;
|
|
|
|
if ( !LaunchNewSteamProcess( pSteamPath ) )
|
|
return 0;
|
|
|
|
return -1;
|
|
} |