static s_mesh_t *FindOrCullMesh( int nLodID, s_source_t *pSrc, int nMaterialID )
{
char baseMeshName[MAX_PATH];
char baseRemovalName[MAX_PATH];
// possibly marked for removal via $removemesh
// determine mesh name
int nTextureID = material_to_texture( nMaterialID );
if (nTextureID == -1)
{
MdlError( "Unknown Texture for Material %d\n", nMaterialID );
}
Q_FileBase(g_texture[nTextureID].name, baseMeshName, sizeof(baseMeshName)-1);
for ( int i = 0; i < g_ScriptLODs[nLodID].meshRemovals.Count(); i++ )
{
const char *pMeshRemovalName = g_ScriptLODs[nLodID].meshRemovals[i].GetSrcName();
Q_FileBase( pMeshRemovalName, baseRemovalName, sizeof(baseRemovalName)-1);
if (!stricmp( baseRemovalName, baseMeshName ))
{
// mesh has been marked for removal
return NULL;
}
}
s_mesh_t *pMesh = FindMeshByMaterial( pSrc, nMaterialID );
return pMesh;
}
void PrecacheFileWeaponInfoDatabase( IFileSystem *filesystem, const unsigned char *pICEKey )
{
if ( m_WeaponInfoDatabase.Count() )
return;
#if !defined( _XBOX )
FileFindHandle_t findHandle;
const char *pFilename = filesystem->FindFirstEx( "scripts/weapon_*.txt", IsXbox() ? "XGAME" : "GAME", &findHandle );
while ( pFilename != NULL )
{
char fileBase[512];
Q_FileBase( pFilename, fileBase, sizeof(fileBase) );
WEAPON_FILE_INFO_HANDLE tmp;
#ifdef CLIENT_DLL
if ( ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey ) )
{
gWR.LoadWeaponSprites( tmp );
}
#else
ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey );
#endif
pFilename = filesystem->FindNext( findHandle );
}
filesystem->FindClose( findHandle );
#else
#define WEAPON_SCRIPT_MANIFEST_FILE "scripts/_weapon_manifest.txt"
// Use a manifest file on the xbox
KeyValues *manifest = new KeyValues( "weaponscripts" );
if ( manifest->LoadFromFile( filesystem, WEAPON_SCRIPT_MANIFEST_FILE, "XGAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL ; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
char fileBase[512];
Q_FileBase( sub->GetString(), fileBase, sizeof(fileBase) );
WEAPON_FILE_INFO_HANDLE tmp;
#ifdef CLIENT_DLL
if ( ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey ) )
{
gWR.LoadWeaponSprites( tmp );
}
#else
ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey );
#endif
}
else
{
Error( "Expecting 'file', got %s\n", sub->GetName() );
}
}
}
manifest->deleteThis();
#endif
}
void PrecacheFileWeaponInfoDatabase( IFileSystem *filesystem, const unsigned char *pICEKey )
{
if ( m_WeaponInfoDatabase.Count() )
return;
KeyValues *manifest = new KeyValues( "weaponscripts" );
if ( manifest->LoadFromFile( filesystem, "scripts/weapon_manifest.txt", "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL ; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
char fileBase[512];
Q_FileBase( sub->GetString(), fileBase, sizeof(fileBase) );
WEAPON_FILE_INFO_HANDLE tmp;
#ifdef CLIENT_DLL
if ( ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey ) )
{
gWR.LoadWeaponSprites( tmp );
}
#else
ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey );
#endif
}
else
{
Error( "Expecting 'file', got %s\n", sub->GetName() );
}
}
}
manifest->deleteThis();
}
void CHL1MP_Player::SetPlayerModel( void )
{
char szBaseName[128];
Q_FileBase( engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" ), szBaseName, 128 );
// Don't let it be 'none'; default to Barney
if ( Q_stricmp( "none", szBaseName ) == 0 )
{
Q_strcpy( szBaseName, "gordon" );
}
char szModelName[256];
Q_snprintf( szModelName, 256, "%s%s/%s.mdl", s_szModelPath, szBaseName, szBaseName );
// Check to see if the model was properly precached, do not error out if not.
int i = modelinfo->GetModelIndex( szModelName );
if ( i == -1 )
{
SetModel( "models/player/mp/gordon/gordon.mdl" );
engine->ClientCommand ( edict(), "cl_playermodel models/gordon.mdl\n" );
return;
}
SetModel( szModelName );
m_flNextModelChangeTime = gpGlobals->curtime + 5;
}
int UTIL_GetMapKeyCount( const char *pszCustomKey )
{
if ( !pszCustomKey )
return 0;
char szFilename[ _MAX_PATH ];
if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )
return 0;
int iCount = 0;
KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );
if ( kvMapLoadFile )
{
kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );
char mapname[MAX_MAP_NAME];
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );
Q_strlower( mapname );
KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );
if ( pMapKey )
{
iCount = pMapKey->GetInt( pszCustomKey );
}
kvMapLoadFile->deleteThis();
}
return iCount;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( m_bCheckedCurrentMap )
return;
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
char szMap[MAX_PATH];
Q_FileBase( engine->GetLevelName(), szMap, ARRAYSIZE( szMap ) );
if ( !IsOfficialMap( szMap ) && !HasPlayedThisCustomMap() )
{
IncrementCount();
Msg( "Count is now %d\n", m_iCount );
UTIL_IncrementMapKey( "killed_a_player" );
}
// stop listening
m_bCheckedCurrentMap = true;
}
}
void CEditorRoot::OnShaderNameChanged()
{
CNodeView *pView = GetSafeFlowgraph();
const char *pszShaderName = pView->GetShadername();
m_pMBut_File->GetMenu()->SetItemEnabled( 2, pszShaderName != NULL );
Label *pTab = (Label*)pNodeSheet->GetActiveTab();
Assert( pTab && GetActiveFlowgraphPage() );
if ( pszShaderName == NULL )
{
//m_pLabel_CurrentFileName->SetText( "-" );
//pView->SetShadername( NULL );
pTab->SetText( GetDefaultTabName( pView ) );
//GetActiveFlowgraphPage()->sett
}
else
{
char tmp[MAX_PATH];
Q_FileBase( pszShaderName, tmp, sizeof( tmp ) );
//m_pLabel_CurrentFileName->SetText( tmp );
pTab->SetText( tmp );
}
for ( int i = 0; i < pNodeSheet->GetNumPages(); i++ )
((Panel*)pNodeSheet->GetTab(i))->InvalidateLayout(true);
pNodeSheet->InvalidateLayout( true, true );
}
void CTilegenKVEditorPage::UpdateListHelper( CASW_KeyValuesDatabase *pMissionDatabase, const char *pFolderName )
{
m_pTree->RemoveAll();
KeyValues *kv = new KeyValues( "TVI" );
kv->SetString( "Text", "Missions" );
int missionIndex = m_pTree->AddItem( kv, -1 );
for ( int i = 0; i < pMissionDatabase->GetFileCount(); i++ )
{
char szMissionFilename[MAX_PATH];
Q_strncpy( szMissionFilename, pMissionDatabase->GetFilename( i ), MAX_PATH );
Q_FixSlashes( szMissionFilename );
int iNode = RecursiveCreateFolderNodes( missionIndex, szMissionFilename + Q_strlen( pFolderName ) );
if ( iNode != missionIndex )
{
m_pTree->ExpandItem( iNode, true );
}
Q_strncpy( szMissionFilename, pMissionDatabase->GetFilename( i ), MAX_PATH );
Q_FileBase( szMissionFilename, szMissionFilename, sizeof( szMissionFilename ) );
KeyValues *pMissionEntry = new KeyValues("MissionEntry");
pMissionEntry->SetString( "Text", szMissionFilename );
pMissionEntry->SetString( "Filename", pMissionDatabase->GetFilename( i ) );
int iItem = m_pTree->AddItem( pMissionEntry, iNode );
m_pTree->SetItemFgColor( iItem, Color(255, 255, 255, 255) );
}
m_pTree->ExpandItem( missionIndex, true );
}
void UTIL_IncrementMapKey( const char *pszCustomKey )
{
if ( !pszCustomKey )
return;
char szFilename[ _MAX_PATH ];
if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )
return;
int iCount = 1;
KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );
if ( kvMapLoadFile )
{
kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );
char mapname[MAX_MAP_NAME];
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );
Q_strlower( mapname );
// Increment existing, or add a new one
KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );
if ( pMapKey )
{
iCount = pMapKey->GetInt( pszCustomKey, 0 ) + 1;
pMapKey->SetInt( pszCustomKey, iCount );
}
else
{
KeyValues *pNewKey = new KeyValues( mapname );
if ( pNewKey )
{
pNewKey->SetString( pszCustomKey, "1" );
kvMapLoadFile->AddSubKey( pNewKey );
}
}
// Write it out
// force create this directory incase it doesn't exist
filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD");
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
kvMapLoadFile->RecursiveSaveToFile( buf, 0 );
g_pFullFileSystem->WriteFile( szFilename, "MOD", buf );
kvMapLoadFile->deleteThis();
}
if ( IsX360() )
{
#ifdef _X360
xboxsystem->FinishContainerWrites();
#endif
}
}
void CEditorRoot::OnAskPageClose( KeyValues *pKV )
{
Panel *pPageTab = (Panel*)pKV->GetPtr( "PageTab" );
CNodeView *pGraph = GetFlowGraph( pKV->GetInt( "TabIndex" ) );
if ( pPageTab == NULL ||
pGraph == NULL )
{
Assert( 0 );
return;
}
ConfirmTabClose( pPageTab->GetVPanel() );
#if 0
if ( !m_bWarnOnClose || !pGraph->IsSaveDirty() )
ConfirmTabClose( pPageTab->GetVPanel() );
else
{
const char *pszShadername = pGraph->GetShadername();
char shortName[MAX_PATH*4];
KeyValues *pKVResponse_Yes = new KeyValues( "ResponseGraphSave", "DoSave", 1 );
KeyValues *pKVResponse_No = new KeyValues( "ResponseGraphSave", "DoSave", 0 );
if ( pszShadername == NULL )
{
pKVResponse_No->deleteThis();
pKVResponse_No = new KeyValues( "ResponseGraphSave", "DoSave", 2 );
}
else
{
Q_FileBase( pszShadername, shortName, sizeof( shortName ) );
}
pKVResponse_Yes->SetPtr( "PageTab", pPageTab );
pKVResponse_No->SetPtr( "PageTab", pPageTab );
pKVResponse_Yes->SetPtr( "Graph", pGraph );
pKVResponse_No->SetPtr( "Graph", pGraph );
vgui::PromptSimple *prompt = new vgui::PromptSimple( this, "Unsaved changes" );
prompt->MoveToCenterOfScreen();
if ( pszShadername != NULL )
prompt->SetText( VarArgs( "The graph %s has unsaved changes. Save now?", shortName ) );
else
prompt->SetText( "This graph has not been saved yet, are you sure that you want to close it?" );
prompt->AddButton( "Yes", pKVResponse_Yes );
prompt->AddButton( "No", pKVResponse_No );
prompt->MakeReadyForUse();
prompt->InvalidateLayout( true, true );
}
#endif
}
void InitMacroTexture( const char *pBSPFilename )
{
// Get the world bounds (same ones used by minimaps and level designers know how to use).
int i = 0;
for (i = 0; i < num_entities; ++i)
{
char* pEntity = ValueForKey(&entities[i], "classname");
if( !strcmp(pEntity, "worldspawn") )
{
GetVectorForKey( &entities[i], "world_mins", g_MacroWorldMins );
GetVectorForKey( &entities[i], "world_maxs", g_MacroWorldMaxs );
break;
}
}
if ( i == num_entities )
{
Warning( "MaskOnMacroTexture: can't find worldspawn" );
return;
}
// Load the macro texture that is mapped onto everything.
char mapName[512], vtfFilename[512];
Q_FileBase( pBSPFilename, mapName, sizeof( mapName ) );
Q_snprintf( vtfFilename, sizeof( vtfFilename ), "materials/macro/%s/base.vtf", mapName );
g_pGlobalMacroTextureData = LoadMacroTextureFile( vtfFilename );
// Now load the macro texture for each face.
g_FaceMacroTextures.SetSize( numfaces );
for ( int iFace=0; iFace < numfaces; iFace++ )
{
g_FaceMacroTextures[iFace] = NULL;
if ( iFace < g_FaceMacroTextureInfos.Count() )
{
unsigned short stringID = g_FaceMacroTextureInfos[iFace].m_MacroTextureNameID;
if ( stringID != 0xFFFF )
{
const char *pMacroTextureName = &g_TexDataStringData[ g_TexDataStringTable[stringID] ];
Q_snprintf( vtfFilename, sizeof( vtfFilename ), "%smaterials/%s.vtf", gamedir, pMacroTextureName );
g_FaceMacroTextures[iFace] = FindMacroTexture( vtfFilename );
if ( !g_FaceMacroTextures[iFace] )
{
g_FaceMacroTextures[iFace] = LoadMacroTextureFile( vtfFilename );
if ( g_FaceMacroTextures[iFace] )
{
g_MacroTextureLookup.Insert( vtfFilename, g_FaceMacroTextures[iFace] );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ReloadParticleEffectsInList( IFileList *pFilesToReload )
{
MEM_ALLOC_CREDIT();
CUtlVector<CUtlString> files;
GetParticleManifest( files );
// CAB 2/17/11 Reload all the particles regardless (Fixes filename change exploits).
bool bReloadAll = true;
//int nCount = files.Count();
//for ( int i = 0; i < nCount; ++i )
//{
// // Skip the precache marker
// const char *pFile = files[i];
// if ( pFile[0] == '!' )
// {
// pFile++;
// }
// char szDX80Filename[MAX_PATH];
// V_strncpy( szDX80Filename, pFile, sizeof( szDX80Filename ) );
// V_StripExtension( pFile, szDX80Filename, sizeof( szDX80Filename ) );
// V_strncat( szDX80Filename, "_dx80.", sizeof( szDX80Filename ) );
// V_strncat( szDX80Filename, V_GetFileExtension( pFile ), sizeof( szDX80Filename ) );
// if ( pFilesToReload->IsFileInList( pFile ) || pFilesToReload->IsFileInList( szDX80Filename ) )
// {
// Msg( "Reloading all particle files due to pure settings.\n" );
// bReloadAll = true;
// break;
// }
//}
// Then check to see if we need to reload the map's particles
const char *pszMapName = NULL;
#ifdef CLIENT_DLL
pszMapName = engine->GetLevelName();
#else
pszMapName = STRING( gpGlobals->mapname );
#endif
if ( pszMapName && pszMapName[0] )
{
char mapname[MAX_MAP_NAME];
Q_FileBase( pszMapName, mapname, sizeof( mapname ) );
Q_strlower( mapname );
ParseParticleEffectsMap( mapname, true, pFilesToReload );
}
if ( bReloadAll )
{
ParseParticleEffects( true, true );
}
g_pParticleSystemMgr->DecommitTempMemory();
}
void CShaderPrecache::OnFileSelected( KeyValues *pKV )
{
const char *pathIn = pKV->GetString( "fullpath" );
if ( Q_strlen( pathIn ) <= 1 )
return;
char dumpname[MAX_PATH];
Q_FileBase( pathIn, dumpname, MAX_PATH );
AddEntry( dumpname );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *basename -
// Output : char *Sys_FindNext
//-----------------------------------------------------------------------------
const char* Sys_FindNext (FileFindHandle_t &searchhandle, char *basename, int namelength)
{
const char *psz = g_pFullFileSystem->FindNext(searchhandle);
if ( basename && psz )
{
Q_FileBase(psz, basename, namelength );
}
return psz;
}
void CHLTVDemoRecorder::StartRecording( const char *filename, bool bContinuously )
{
StopRecording(); // stop if we're already recording
if ( !m_DemoFile.Open( filename, false ) )
{
ConMsg ("StartRecording: couldn't open demo file %s.\n", filename );
return;
}
ConMsg ("Recording SourceTV demo to %s...\n", filename);
demoheader_t *dh = &m_DemoFile.m_DemoHeader;
// open demo header file containing sigondata
Q_memset( dh, 0, sizeof(demoheader_t));
Q_strncpy( dh->demofilestamp, DEMO_HEADER_ID, sizeof(dh->demofilestamp) );
dh->demoprotocol = DEMO_PROTOCOL;
dh->networkprotocol = PROTOCOL_VERSION;
Q_strncpy( dh->mapname, hltv->GetMapName(), sizeof( dh->mapname ) );
char szGameDir[MAX_OSPATH];
Q_strncpy(szGameDir, com_gamedir, sizeof( szGameDir ) );
Q_FileBase ( szGameDir, dh->gamedirectory, sizeof( dh->gamedirectory ) );
Q_strncpy( dh->servername, host_name.GetString(), sizeof( dh->servername ) );
Q_strncpy( dh->clientname, "SourceTV Demo", sizeof( dh->servername ) );
// write demo file header info
m_DemoFile.WriteDemoHeader();
dh->signonlength = WriteSignonData(); // demoheader will be written when demo is closed
m_nFrameCount = 0;
m_nStartTick = host_tickcount;
// Demo playback should read this as an incoming message.
// Write the client's realtime value out so we can synchronize the reads.
m_DemoFile.WriteCmdHeader( dem_synctick, 0 );
m_bIsRecording = true;
m_SequenceInfo = 1;
m_nDeltaTick = -1;
}
const char *Sys_FindFirst (FileFindHandle_t &searchhandle, const char *path, char *basename, int namelength )
{
if (searchhandle != FILESYSTEM_INVALID_FIND_HANDLE)
{
Msg("Sys_FindFirst without close");
g_pFullFileSystem->FindClose(searchhandle);
}
const char* psz = g_pFullFileSystem->FindFirst(path, &searchhandle);
if (basename && psz)
{
Q_FileBase(psz, basename, namelength );
}
return psz;
}
//-----------------------------------------------------------------------------
// Searches for a material in the texture list
//-----------------------------------------------------------------------------
int FindMaterialByName( const char *pMaterialName )
{
int i;
int allocLen = strlen( pMaterialName ) + 1;
char *pBaseName = ( char * )_alloca( allocLen );
Q_FileBase( ( char * )pMaterialName, pBaseName, allocLen );
for( i = 0; i < g_numtextures; i++ )
{
if( stricmp( pBaseName, g_texture[i].name ) == 0 )
{
return i;
}
}
return -1;
}
unsigned short UTIL_GetAchievementEventMask( void )
{
CRC32_t mapCRC;
CRC32_Init( &mapCRC );
char lowercase[ 256 ];
#ifdef CLIENT_DLL
Q_FileBase( engine->GetLevelName(), lowercase, sizeof( lowercase ) );
#else
Q_strncpy( lowercase, STRING( gpGlobals->mapname ), sizeof( lowercase ) );
#endif
Q_strlower( lowercase );
CRC32_ProcessBuffer( &mapCRC, lowercase, Q_strlen( lowercase ) );
CRC32_Final( &mapCRC );
return ( mapCRC & 0xFFFF );
}
bool VMPI_Stats_Init_Master(
const char *pHostName,
const char *pDBName,
const char *pUserName,
const char *pBSPFilename,
unsigned long *pDBJobID )
{
Assert( !g_pDB );
g_bMaster = true;
// Connect the database.
g_pDB = new CMySqlDatabase;
if ( !g_pDB || !g_pDB->Initialize() || !LoadMySQLWrapper( pHostName, pDBName, pUserName ) )
{
delete g_pDB;
g_pDB = NULL;
return false;
}
DWORD size = sizeof( g_MachineName );
GetComputerName( g_MachineName, &size );
// Create the job_master_start row.
Q_FileBase( pBSPFilename, g_BSPFilename, sizeof( g_BSPFilename ) );
g_JobPrimaryID = 0;
CMySQLQuery query;
query.Format( "insert into job_master_start ( BSPFilename, StartTime, MachineName, RunningTimeMS ) values ( \"%s\", null, \"%s\", %lu )", g_BSPFilename, g_MachineName, RUNNINGTIME_MS_SENTINEL );
query.Execute( g_pSQL );
g_JobPrimaryID = g_pSQL->InsertID();
if ( g_JobPrimaryID == 0 )
{
delete g_pDB;
g_pDB = NULL;
return false;
}
// Now init the worker portion.
*pDBJobID = g_JobPrimaryID;
return VMPI_Stats_Init_Worker( NULL, NULL, NULL, g_JobPrimaryID );
}
//-----------------------------------------------------------------------------
// Purpose: returns true if the font is equivalent to that specified
//-----------------------------------------------------------------------------
bool CBitmapFont::IsEqualTo( const char *windowsFontName, float scalex, float scaley, int flags )
{
char fontname[MAX_PATH];
Q_FileBase( windowsFontName, fontname, MAX_PATH );
if ( !Q_stricmp( fontname, m_szName.String() ) &&
m_scalex == scalex &&
m_scaley == scaley )
{
int commonFlags = m_iFlags & flags;
if ( commonFlags & vgui::ISurface::FONTFLAG_ADDITIVE )
{
// an exact match
return true;
}
}
return false;
}
int UTIL_GetMapKeyCount( const char *pszCustomKey )
{
if ( !pszCustomKey )
return 0;
char szFilename[ _MAX_PATH ];
if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )
return 0;
int iCount = 0;
KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );
if ( kvMapLoadFile )
{
// create an empty file if none exists
if ( !g_pFullFileSystem->FileExists( szFilename, "MOD" ) )
{
// force create this directory incase it doesn't exist
filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD");
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
g_pFullFileSystem->WriteFile( szFilename, "MOD", buf );
}
kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );
char mapname[MAX_MAP_NAME];
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );
Q_strlower( mapname );
KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );
if ( pMapKey )
{
iCount = pMapKey->GetInt( pszCustomKey );
}
kvMapLoadFile->deleteThis();
}
return iCount;
}
//-----------------------------------------------------------------------------
// Purpose: Add a new configuration with proper defaults to a keyvalue block
//-----------------------------------------------------------------------------
bool AddConfig( int configID )
{
// Find the games block of the keyvalues
KeyValues *gameBlock = g_ConfigManager.GetGameBlock();
if ( gameBlock == NULL )
{
Assert( 0 );
return false;
}
// Set to defaults
defaultConfigInfo_t newInfo;
memset( &newInfo, 0, sizeof( newInfo ) );
// Data for building the new configuration
const char *pModName = g_Configs[configID]->m_Name.Base();
const char *pModDirectory = g_Configs[configID]->m_ModDir.Base();
// Mod name
Q_strncpy( newInfo.gameName, pModName, sizeof( newInfo.gameName ) );
// FGD
Q_strncpy( newInfo.FGD, "base.fgd", sizeof( newInfo.FGD ) );
// Get the base directory
Q_FileBase( pModDirectory, newInfo.gameDir, sizeof( newInfo.gameDir ) );
// Default executable
Q_strncpy( newInfo.exeName, "hl2.exe", sizeof( newInfo.exeName ) );
char szPath[MAX_PATH];
Q_strncpy( szPath, pModDirectory, sizeof( szPath ) );
Q_StripLastDir( szPath, sizeof( szPath ) );
Q_StripTrailingSlash( szPath );
char fullDir[MAX_PATH];
g_ConfigManager.GetRootGameDirectory( fullDir, sizeof( fullDir ), g_ConfigManager.GetRootDirectory(), "half-life 2" );
return g_ConfigManager.AddDefaultConfig( newInfo, gameBlock, szPath, fullDir );
}
void CopyDev()
{
FileFindHandle_t handle;
char steamappsPath[MAX_PATH*4];
const char *pszGameDir = engine->GetGameDirectory();
Q_strcpy( steamappsPath, pszGameDir );
Q_StripLastDir( steamappsPath, sizeof(steamappsPath) );
Q_StripLastDir( steamappsPath, sizeof(steamappsPath) );
char searchPath[MAX_PATH*4];
Q_snprintf( searchPath, sizeof(searchPath), "%s\\shaders\\fxc\\*", pszGameDir );
Q_FixSlashes( searchPath );
Msg( "searching for shaders in: %s\n", searchPath );
const char *pszName = g_pFullFileSystem->FindFirst( searchPath, &handle );
while ( pszName != NULL )
{
if ( Q_strlen( pszName ) > 4 )
{
char filename[MAX_PATH];
Q_FileBase( pszName, filename, sizeof( filename ) );
char filepath_src[MAX_PATH];
char filepath_dst[MAX_PATH];
Q_snprintf( filepath_src, sizeof( filepath_src ), "%s\\shaders\\fxc\\%s.vcs\0", pszGameDir, filename );
Q_snprintf( filepath_dst, sizeof( filepath_dst ), "%s\\common\\alien swarm\\platform\\shaders\\fxc\\%s.vcs\0", steamappsPath, filename );
Q_FixSlashes( filepath_src );
Q_FixSlashes( filepath_dst );
Msg( "%s --> %s\n", filepath_src, filepath_dst );
engine->CopyFile( filepath_src, filepath_dst );
}
pszName = g_pFullFileSystem->FindNext( handle );
}
g_pFullFileSystem->FindClose( handle );
}
bool CommandMenu::LoadFromKeyValues( KeyValues * params )
{
if ( !params )
return false;
Q_snprintf( m_CurrentTeam, 4, "%i", GetLocalPlayerTeam() );
Q_FileBase( engine->GetLevelName(), m_CurrentMap, sizeof(m_CurrentMap) );
if ( params != m_MenuKeys )
{
if ( m_MenuKeys )
m_MenuKeys->deleteThis();
m_MenuKeys = params->MakeCopy(); // save keyvalues
}
// iterate through all menu items
KeyValues * subkey = m_MenuKeys->GetFirstSubKey();
while ( subkey )
{
if ( subkey->GetDataType() == KeyValues::TYPE_NONE )
{
if ( !LoadFromKeyValuesInternal( subkey, 0 ) ) // recursive call
return false;
}
subkey = subkey->GetNextKey();
}
UpdateMenu();
return true;
}
int RunVVis( int argc, char **argv )
{
char portalfile[1024];
char source[1024];
double start, end;
Msg( "Valve Software - vvis.exe (%s)\n", __DATE__ );
verbose = false;
Q_StripExtension( argv[ argc - 1 ], source, sizeof( source ) );
CmdLib_InitFileSystem( argv[ argc - 1 ] );
Q_FileBase( source, source, sizeof( source ) );
LoadCmdLineFromFile( argc, argv, source, "vvis" );
int i = ParseCommandLine( argc, argv );
// This part is just for VMPI. VMPI's file system needs the basedir in front of all filenames,
// so we prepend qdir here.
strcpy( source, ExpandPath( source ) );
if (i != argc - 1)
{
PrintUsage( argc, argv );
DeleteCmdLine( argc, argv );
CmdLib_Exit( 1 );
}
start = Plat_FloatTime();
if (!g_bUseMPI)
{
// Setup the logfile.
char logFile[512];
_snprintf( logFile, sizeof(logFile), "%s.log", source );
SetSpewFunctionLogFile( logFile );
}
// Run in the background?
if( g_bLowPriority )
{
SetLowPriority();
}
ThreadSetDefault ();
char targetPath[1024];
GetPlatformMapPath( source, targetPath, 0, 1024 );
Msg ("reading %s\n", targetPath);
LoadBSPFile (targetPath);
if (numnodes == 0 || numfaces == 0)
Error ("Empty map");
ParseEntities ();
// Check the VMF for a vis radius
if (!g_bUseRadius)
{
float flRadius = DetermineVisRadius( );
if (flRadius > 0.0f)
{
g_bUseRadius = true;
g_VisRadius = flRadius * flRadius;
}
}
if ( g_bUseRadius )
{
MarkLeavesAsRadial();
}
if ( inbase[0] == 0 )
{
strcpy( portalfile, source );
}
else
{
sprintf ( portalfile, "%s%s", inbase, argv[i] );
Q_StripExtension( portalfile, portalfile, sizeof( portalfile ) );
}
strcat (portalfile, ".prt");
Msg ("reading %s\n", portalfile);
LoadPortals (portalfile);
CalcVis ();
CalcPAS ();
// We need a mapping from cluster to leaves, since the PVS
// deals with clusters for both CalcVisibleFogVolumes and
BuildClusterTable();
CalcVisibleFogVolumes();
CalcDistanceFromLeavesToWater();
visdatasize = vismap_p - dvisdata;
Msg ("visdatasize:%i compressed from %i\n", visdatasize, originalvismapsize*2);
Msg ("writing %s\n", targetPath);
WriteBSPFile (targetPath);
end = Plat_FloatTime();
char str[512];
GetHourMinuteSecondsString( (int)( end - start ), str, sizeof( str ) );
Msg( "%s elapsed\n", str );
DeleteCmdLine( argc, argv );
CmdLib_Cleanup();
return 0;
}
void CBaseGameStats_Driver::CollectData( StatSendType_t sendType )
{
CGamestatsData *pGamestatsData = NULL;
#ifdef GAME_DLL
// for server, check with the engine to see if there already a gamestats data container registered. (There will be if there is a client
// running in the same process.)
pGamestatsData = engine->GetGamestatsData();
if ( pGamestatsData )
{
// use the registered gamestats container, so free the one we allocated
if ( m_pGamestatsData != NULL )
{
delete m_pGamestatsData;
m_pGamestatsData = NULL;
}
}
else
{
pGamestatsData = m_pGamestatsData;
}
#else
pGamestatsData = m_pGamestatsData;
#endif
Assert( pGamestatsData );
KeyValues *pKV = pGamestatsData->m_pKVData;
int iAppID = engine->GetAppID();
pKV->SetInt( "appid", iAppID );
switch ( sendType )
{
case STATSEND_LEVELSHUTDOWN:
{
// make a map node in the KeyValues to use for this level
char szMap[MAX_PATH+1]="";
#ifdef CLIENT_DLL
Q_FileBase( engine->GetLevelName(), szMap, ARRAYSIZE( szMap ) );
#else
Q_strncpy( szMap, gpGlobals->mapname.ToCStr(), ARRAYSIZE( szMap ) );
#endif // CLIENT_DLL
if ( !szMap[0] )
return;
KeyValues *pKVMap = new KeyValues( "map" );
pKV->AddSubKey( pKVMap );
pKVMap->SetString( "mapname", szMap );
pKV = pKVMap;
}
break;
case STATSEND_APPSHUTDOWN:
break;
default:
Assert( false );
break;
}
// add common data
pGamestatsData->m_bHaveData |= AddBaseDataForSend( pKV, sendType );
// add game-specific data
pGamestatsData->m_bHaveData |= gamestats->AddDataForSend( pKV, sendType );
}
int RunVBSP( int argc, char **argv )
{
int i;
double start, end;
char path[1024];
CommandLine()->CreateCmdLine( argc, argv );
MathLib_Init( 2.2f, 2.2f, 0.0f, OVERBRIGHT, false, false, false, false );
InstallSpewFunction();
SpewActivate( "developer", 1 );
CmdLib_InitFileSystem( argv[ argc-1 ] );
Q_StripExtension( ExpandArg( argv[ argc-1 ] ), source, sizeof( source ) );
Q_FileBase( source, mapbase, sizeof( mapbase ) );
strlwr( mapbase );
LoadCmdLineFromFile( argc, argv, mapbase, "vbsp" );
Msg( "Valve Software - vbsp.exe (%s)\n", __DATE__ );
for (i=1 ; i<argc ; i++)
{
if (!stricmp(argv[i],"-threads"))
{
numthreads = atoi (argv[i+1]);
i++;
}
else if (!Q_stricmp(argv[i],"-glview"))
{
glview = true;
}
else if ( !Q_stricmp(argv[i], "-v") || !Q_stricmp(argv[i], "-verbose") )
{
Msg("verbose = true\n");
verbose = true;
}
else if (!Q_stricmp(argv[i], "-noweld"))
{
Msg ("noweld = true\n");
noweld = true;
}
else if (!Q_stricmp(argv[i], "-nocsg"))
{
Msg ("nocsg = true\n");
nocsg = true;
}
else if (!Q_stricmp(argv[i], "-noshare"))
{
Msg ("noshare = true\n");
noshare = true;
}
else if (!Q_stricmp(argv[i], "-notjunc"))
{
Msg ("notjunc = true\n");
notjunc = true;
}
else if (!Q_stricmp(argv[i], "-nowater"))
{
Msg ("nowater = true\n");
nowater = true;
}
else if (!Q_stricmp(argv[i], "-noopt"))
{
Msg ("noopt = true\n");
noopt = true;
}
else if (!Q_stricmp(argv[i], "-noprune"))
{
Msg ("noprune = true\n");
noprune = true;
}
else if (!Q_stricmp(argv[i], "-nomerge"))
{
Msg ("nomerge = true\n");
nomerge = true;
}
else if (!Q_stricmp(argv[i], "-nomergewater"))
{
Msg ("nomergewater = true\n");
nomergewater = true;
}
else if (!Q_stricmp(argv[i], "-nosubdiv"))
{
Msg ("nosubdiv = true\n");
nosubdiv = true;
}
else if (!Q_stricmp(argv[i], "-nodetail"))
{
Msg ("nodetail = true\n");
nodetail = true;
}
else if (!Q_stricmp(argv[i], "-fulldetail"))
{
Msg ("fulldetail = true\n");
fulldetail = true;
}
else if (!Q_stricmp(argv[i], "-onlyents"))
{
Msg ("onlyents = true\n");
onlyents = true;
}
else if (!Q_stricmp(argv[i], "-onlyprops"))
{
Msg ("onlyprops = true\n");
onlyprops = true;
}
else if (!Q_stricmp(argv[i], "-micro"))
{
microvolume = atof(argv[i+1]);
Msg ("microvolume = %f\n", microvolume);
i++;
}
else if (!Q_stricmp(argv[i], "-leaktest"))
{
Msg ("leaktest = true\n");
leaktest = true;
}
else if (!Q_stricmp(argv[i], "-verboseentities"))
{
Msg ("verboseentities = true\n");
verboseentities = true;
}
else if (!Q_stricmp(argv[i], "-snapaxial"))
{
Msg ("snap axial = true\n");
g_snapAxialPlanes = true;
}
#if 0
else if (!Q_stricmp(argv[i], "-maxlightmapdim"))
{
g_maxLightmapDimension = atof(argv[i+1]);
Msg ("g_maxLightmapDimension = %f\n", g_maxLightmapDimension);
i++;
}
#endif
else if (!Q_stricmp(argv[i], "-block"))
{
block_xl = block_xh = atoi(argv[i+1]);
block_yl = block_yh = atoi(argv[i+2]);
Msg ("block: %i,%i\n", block_xl, block_yl);
i+=2;
}
else if (!Q_stricmp(argv[i], "-blocks"))
{
block_xl = atoi(argv[i+1]);
block_yl = atoi(argv[i+2]);
block_xh = atoi(argv[i+3]);
block_yh = atoi(argv[i+4]);
Msg ("blocks: %i,%i to %i,%i\n",
block_xl, block_yl, block_xh, block_yh);
i+=4;
}
else if ( !Q_stricmp( argv[i], "-dumpcollide" ) )
{
Msg("Dumping collision models to collideXXX.txt\n" );
dumpcollide = true;
}
else if ( !Q_stricmp( argv[i], "-dumpstaticprop" ) )
{
Msg("Dumping static props to staticpropXXX.txt\n" );
g_DumpStaticProps = true;
}
else if ( !Q_stricmp( argv[i], "-forceskyvis" ) )
{
Msg("Enabled vis in 3d skybox\n" );
g_bSkyVis = true;
}
else if (!Q_stricmp (argv[i],"-tmpout"))
{
strcpy (outbase, "/tmp");
}
#if 0
else if( !Q_stricmp( argv[i], "-defaultluxelsize" ) )
{
g_defaultLuxelSize = atof( argv[i+1] );
i++;
}
#endif
else if( !Q_stricmp( argv[i], "-luxelscale" ) )
{
g_luxelScale = atof( argv[i+1] );
i++;
}
else if( !strcmp( argv[i], "-minluxelscale" ) )
{
g_minLuxelScale = atof( argv[i+1] );
if (g_minLuxelScale < 1)
g_minLuxelScale = 1;
i++;
}
else if( !Q_stricmp( argv[i], "-dxlevel" ) )
{
g_nDXLevel = atoi( argv[i+1] );
Msg( "DXLevel = %d\n", g_nDXLevel );
i++;
}
else if( !Q_stricmp( argv[i], "-bumpall" ) )
{
g_BumpAll = true;
}
else if( !Q_stricmp( argv[i], "-low" ) )
{
g_bLowPriority = true;
}
else if( !Q_stricmp( argv[i], "-lightifmissing" ) )
{
g_bLightIfMissing = true;
}
else if ( !Q_stricmp( argv[i], CMDLINEOPTION_NOVCONFIG ) )
{
}
else if ( !Q_stricmp( argv[i], "-allowdebug" ) || !Q_stricmp( argv[i], "-steam" ) )
{
// nothing to do here, but don't bail on this option
}
else if ( !Q_stricmp( argv[i], "-vproject" ) || !Q_stricmp( argv[i], "-game" ) )
{
++i;
}
else if ( !Q_stricmp( argv[i], "-keepstalezip" ) )
{
g_bKeepStaleZip = true;
}
else if ( !Q_stricmp( argv[i], "-xbox" ) )
{
// enable mandatory xbox extensions
g_NodrawTriggers = true;
g_DisableWaterLighting = true;
}
else if ( !Q_stricmp( argv[i], "-allowdetailcracks"))
{
g_bAllowDetailCracks = true;
}
else if ( !Q_stricmp( argv[i], "-novirtualmesh"))
{
g_bNoVirtualMesh = true;
}
else if ( !Q_stricmp( argv[i], "-replacematerials" ) )
{
g_ReplaceMaterials = true;
}
else if ( !Q_stricmp(argv[i], "-nodrawtriggers") )
{
g_NodrawTriggers = true;
}
else if ( !Q_stricmp( argv[i], "-FullMinidumps" ) )
{
EnableFullMinidumps( true );
}
else if (argv[i][0] == '-')
{
Warning("VBSP: Unknown option \"%s\"\n\n", argv[i]);
i = 100000; // force it to print the usage
break;
}
else
break;
}
if (i != argc - 1)
{
PrintCommandLine( argc, argv );
Warning(
"usage : vbsp [options...] mapfile\n"
"example: vbsp -onlyents c:\\hl2\\hl2\\maps\\test\n"
"\n"
"Common options (use -v to see all options):\n"
"\n"
" -v (or -verbose): Turn on verbose output (also shows more command\n"
" line options).\n"
"\n"
" -onlyents : This option causes vbsp only import the entities from the .vmf\n"
" file. -onlyents won't reimport brush models.\n"
" -onlyprops : Only update the static props and detail props.\n"
" -glview : Writes .gl files in the current directory that can be viewed\n"
" with glview.exe. If you use -tmpout, it will write the files\n"
" into the \\tmp folder.\n"
" -nodetail : Get rid of all detail geometry. The geometry left over is\n"
" what affects visibility.\n"
" -nowater : Get rid of water brushes.\n"
" -low : Run as an idle-priority process.\n"
"\n"
" -vproject <directory> : Override the VPROJECT environment variable.\n"
" -game <directory> : Same as -vproject.\n"
"\n" );
if ( verbose )
{
Warning(
"Other options :\n"
" -novconfig : Don't bring up graphical UI on vproject errors.\n"
" -threads : Control the number of threads vbsp uses (defaults to the # of\n"
" processors on your machine).\n"
" -verboseentities: If -v is on, this disables verbose output for submodels.\n"
" -noweld : Don't join face vertices together.\n"
" -nocsg : Don't chop out intersecting brush areas.\n"
" -noshare : Emit unique face edges instead of sharing them.\n"
" -notjunc : Don't fixup t-junctions.\n"
" -noopt : By default, vbsp removes the 'outer shell' of the map, which\n"
" are all the faces you can't see because you can never get\n"
" outside the map. -noopt disables this behaviour.\n"
" -noprune : Don't prune neighboring solid nodes.\n"
" -nomerge : Don't merge together chopped faces on nodes.\n"
" -nomergewater: Don't merge together chopped faces on water.\n"
" -nosubdiv : Don't subdivide faces for lightmapping.\n"
" -micro <#> : vbsp will warn when brushes are output with a volume less\n"
" than this number (default: 1.0).\n"
" -fulldetail : Mark all detail geometry as normal geometry (so all detail\n"
" geometry will affect visibility).\n"
" -leaktest : Stop processing the map if a leak is detected. Whether or not\n"
" this flag is set, a leak file will be written out at\n"
" <vmf filename>.lin, and it can be imported into Hammer.\n"
" -bumpall : Force all surfaces to be bump mapped.\n"
" -snapaxial : Snap axial planes to integer coordinates.\n"
" -block # # : Control the grid size mins that vbsp chops the level on.\n"
" -blocks # # # # : Enter the mins and maxs for the grid size vbsp uses.\n"
" -dumpstaticprops: Dump static props to staticprop*.txt\n"
" -dumpcollide : Write files with collision info.\n"
" -forceskyvis : Enable vis calculations in 3d skybox leaves\n"
" -luxelscale # : Scale all lightmaps by this amount (default: 1.0).\n"
" -minluxelscale #: No luxel scale will be lower than this amount (default: 1.0).\n"
" -lightifmissing : Force lightmaps to be generated for all surfaces even if\n"
" they don't need lightmaps.\n"
" -keepstalezip : Keep the BSP's zip files intact but regenerate everything\n"
" else.\n"
" -virtualdispphysics : Use virtual (not precomputed) displacement collision models\n"
" -xbox : Enable mandatory xbox options\n"
" -x360 : Generate Xbox360 version of vsp\n"
" -nox360 : Disable generation Xbox360 version of vsp (default)\n"
" -replacematerials : Substitute materials according to materialsub.txt in content\\maps\n"
" -FullMinidumps : Write large minidumps on crash.\n"
);
}
DeleteCmdLine( argc, argv );
CmdLib_Cleanup();
CmdLib_Exit( 1 );
}
start = Plat_FloatTime();
// Run in the background?
if( g_bLowPriority )
{
SetLowPriority();
}
if( ( g_nDXLevel != 0 ) && ( g_nDXLevel < 80 ) )
{
g_BumpAll = false;
}
if( g_luxelScale == 1.0f )
{
if ( g_nDXLevel == 70 )
{
g_luxelScale = 4.0f;
}
}
ThreadSetDefault ();
numthreads = 1; // multiple threads aren't helping...
// Setup the logfile.
char logFile[512];
_snprintf( logFile, sizeof(logFile), "%s.log", source );
SetSpewFunctionLogFile( logFile );
LoadPhysicsDLL();
LoadSurfaceProperties();
#if 0
Msg( "qdir: %s This is the the path of the initial source file \n", qdir );
Msg( "gamedir: %s This is the base engine + mod-specific game dir (e.g. d:/tf2/mytfmod/) \n", gamedir );
Msg( "basegamedir: %s This is the base engine + base game directory (e.g. e:/hl2/hl2/, or d:/tf2/tf2/ )\n", basegamedir );
#endif
sprintf( materialPath, "%smaterials", gamedir );
InitMaterialSystem( materialPath, CmdLib_GetFileSystemFactory() );
Msg( "materialPath: %s\n", materialPath );
// delete portal and line files
sprintf (path, "%s.prt", source);
remove (path);
sprintf (path, "%s.lin", source);
remove (path);
strcpy (name, ExpandArg (argv[i]));
const char *pszExtension = V_GetFileExtension( name );
if ( !pszExtension )
{
V_SetExtension( name, ".vmm", sizeof( name ) );
if ( !FileExists( name ) )
{
V_SetExtension( name, ".vmf", sizeof( name ) );
}
}
char platformBSPFileName[1024];
GetPlatformMapPath( source, platformBSPFileName, g_nDXLevel, 1024 );
// if we're combining materials, load the script file
if ( g_ReplaceMaterials )
{
LoadMaterialReplacementKeys( gamedir, mapbase );
}
//
// if onlyents, just grab the entites and resave
//
if (onlyents)
{
LoadBSPFile (platformBSPFileName);
num_entities = 0;
// Clear out the cubemap samples since they will be reparsed even with -onlyents
g_nCubemapSamples = 0;
// Mark as stale since the lighting could be screwed with new ents.
AddBufferToPak( GetPakFile(), "stale.txt", "stale", strlen( "stale" ) + 1, false );
LoadMapFile (name);
SetModelNumbers ();
SetLightStyles ();
// NOTE: If we ever precompute lighting for static props in
// vrad, EmitStaticProps should be removed here
// Emit static props found in the .vmf file
EmitStaticProps();
// NOTE: Don't deal with detail props here, it blows away lighting
// Recompute the skybox
ComputeBoundsNoSkybox();
// Make sure that we have a water lod control eneity if we have water in the map.
EnsurePresenceOfWaterLODControlEntity();
// Make sure the func_occluders have the appropriate data set
FixupOnlyEntsOccluderEntities();
// Doing this here because stuff abov may filter out entities
UnparseEntities ();
WriteBSPFile (platformBSPFileName);
}
else if (onlyprops)
{
// In the only props case, deal with static + detail props only
LoadBSPFile (platformBSPFileName);
LoadMapFile(name);
SetModelNumbers();
SetLightStyles();
// Emit static props found in the .vmf file
EmitStaticProps();
// Place detail props found in .vmf and based on material properties
LoadEmitDetailObjectDictionary( gamedir );
EmitDetailObjects();
WriteBSPFile (platformBSPFileName);
}
else
{
//
// start from scratch
//
// Load just the file system from the bsp
if( g_bKeepStaleZip && FileExists( platformBSPFileName ) )
{
LoadBSPFile_FileSystemOnly (platformBSPFileName);
// Mark as stale since the lighting could be screwed with new ents.
AddBufferToPak( GetPakFile(), "stale.txt", "stale", strlen( "stale" ) + 1, false );
}
LoadMapFile (name);
WorldVertexTransitionFixup();
if( ( g_nDXLevel == 0 ) || ( g_nDXLevel >= 70 ) )
{
Cubemap_FixupBrushSidesMaterials();
Cubemap_AttachDefaultCubemapToSpecularSides();
Cubemap_AddUnreferencedCubemaps();
}
SetModelNumbers ();
SetLightStyles ();
LoadEmitDetailObjectDictionary( gamedir );
ProcessModels ();
}
end = Plat_FloatTime();
char str[512];
GetHourMinuteSecondsString( (int)( end - start ), str, sizeof( str ) );
Msg( "%s elapsed\n", str );
DeleteCmdLine( argc, argv );
ReleasePakFileLumps();
DeleteMaterialReplacementKeys();
ShutdownMaterialSystem();
CmdLib_Cleanup();
return 0;
}
void BuildMessage( bf_write& buf, byte msgtype, char const *mapname, unsigned int uSessionID )
{
bf_write encrypted;
byte encrypted_data[ 2048 ];
buf.WriteByte( C2M_PHONEHOME );
buf.WriteByte( '\n' );
buf.WriteByte( C2M_PHONEHOME_PROTOCOL_VERSION );
buf.WriteLong( uSessionID ); // sessionid (request new id by sending 0)
// encryption object
IceKey cipher(1); /* medium encryption level */
unsigned char ucEncryptionKey[8] = { 191, 1, 0, 222, 85, 39, 154, 1 };
cipher.set( ucEncryptionKey );
encrypted.StartWriting( encrypted_data, sizeof( encrypted_data ) );
byte corruption_identifier = 0x01;
encrypted.WriteByte( corruption_identifier );
// Data version protocol
encrypted.WriteByte( 1 );
// Write the "build identifier" -- unique to each person we give a build to.
encrypted.WriteString( m_szBuildIdentifier );
{
char computername[ 64 ];
Q_memset( computername, 0, sizeof( computername ) );
#if defined ( _WIN32 )
DWORD length = sizeof( computername ) - 1;
if ( !GetComputerName( computername, &length ) )
{
Q_strncpy( computername, "???", sizeof( computername ) );
}
#else
if ( gethostname( computername, sizeof(computername) ) == -1 )
{
Q_strncpy( computername, "Linux????", sizeof( computername ) );
}
computername[sizeof(computername)-1] = '\0';
#endif
encrypted.WriteString( computername );
}
{
char username[ 64 ];
Q_memset( username, 0, sizeof( username ) );
#if defined ( _WIN32 )
DWORD length = sizeof( username ) - 1;
if ( !GetUserName( username, &length ) )
{
Q_strncpy( username, "???", sizeof( username ) );
}
#else
struct passwd *pass = getpwuid( getuid() );
if ( pass )
{
Q_strncpy( username, pass->pw_name, sizeof( username ) );
}
else
{
Q_strncpy( username, "LinuxUser??", sizeof( username ) );
}
username[sizeof(username)-1] = '\0';
#endif
encrypted.WriteString( username );
}
char gamedir[ 64 ];
Q_FileBase( com_gamedir, gamedir, sizeof( gamedir ) );
encrypted.WriteString( gamedir );
unsigned int uBuildNumber = build_number();
encrypted.WriteLong( (int)uBuildNumber );
// WRite timestamp of engine
encrypted.WriteFloat( (float)realtime );
encrypted.WriteByte( msgtype );
if ( mapname != NULL )
{
encrypted.WriteString( mapname );
}
int isDebugUser = ( Sys_IsDebuggerPresent() || CommandLine()->FindParm( "-allowdebug" ) ) ? 1 : 0;
encrypted.WriteByte( isDebugUser );
while ( encrypted.GetNumBytesWritten() % 8 )
{
encrypted.WriteByte( 0 );
}
EncryptBuffer( cipher, (unsigned char *)encrypted.GetData(), encrypted.GetNumBytesWritten() );
buf.WriteShort( (int)encrypted.GetNumBytesWritten() );
buf.WriteBytes( (unsigned char *)encrypted.GetData(), encrypted.GetNumBytesWritten() );
}
//-----------------------------------------------------------------------------
// Creates a single sfm file
//-----------------------------------------------------------------------------
void CSFMGenApp::GenerateSFMFile( const SFMGenInfo_t& sfmGenInfo, const SFMInfo_t &info,
studiohdr_t *pStudioHdr, const char *pOutputDirectory, const char *pExportFacPath )
{
CSFMSession session;
session.Init();
char pAnimationSetName[256];
Q_FileBase( pStudioHdr->name, pAnimationSetName, sizeof(pAnimationSetName) );
// Set the file id( necessary for phoneme extraction)
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( pAnimationSetName );
session.Root()->SetFileId( fileid, TD_DEEP );
g_pModelPresetGroupMgr->AssociatePresetsWithFile( fileid );
// Get the shot.
CDmeFilmClip *pMovie = session.Root()->GetValueElement<CDmeFilmClip>( "activeClip" );
CDmeFilmClip* pShot = CastElement< CDmeFilmClip >( pMovie->GetFilmTrack()->GetClip( 0 ) );
// Create a camera for the shot
DmeCameraParams_t cameraParams( pAnimationSetName, vec3_origin, QAngle( 0, 180, 0 ) );
cameraParams.origin.x = pStudioHdr->hull_max.x + 20;
cameraParams.origin.z = Lerp( 0.95f, pStudioHdr->hull_min.z, pStudioHdr->hull_max.z );
cameraParams.fov = 75.0f;
CDmeCamera* pCamera = session.CreateCamera( cameraParams );
pShot->SetCamera( pCamera );
// Create a game model for the studio hdr
CDmeGameModel *pGameModel = session.CreateEditorGameModel( pStudioHdr, vec3_origin, Quaternion( 0, 0, 0, 1 ) );
// Create a scene for the shot
CDmeDag *pScene = session.FindOrCreateScene( pShot, pAnimationSetName );
pScene->AddChild( pGameModel );
// Create a sound clip
CDmeGameSound *pGameSound;
CDmeSoundClip *pSoundClip = CreateSoundClip( pMovie, pAnimationSetName, info.m_GameSound, pStudioHdr, &pGameSound );
pShot->SetDuration( pSoundClip->GetDuration() );
pMovie->SetDuration( pSoundClip->GetDuration() );
// Create an animation set
CDmeAnimationSet *pAnimationSet = CreateAnimationSet( pMovie, pShot, pGameModel, pAnimationSetName, 0, false );
// Extract phonemes
if ( pSoundClip )
{
CExtractInfo extractInfo;
extractInfo.m_pClip = pSoundClip;
extractInfo.m_pSound = pGameSound;
extractInfo.m_sHintText = info.m_Text;
extractInfo.m_bUseSentence = sfmGenInfo.m_bUsePhonemesInWavs;
ExtractDesc_t extractDesc;
extractDesc.m_nExtractType = EXTRACT_WIPE_CLIP;
extractDesc.m_pMovie = pMovie;
extractDesc.m_pShot = pShot;
extractDesc.m_pSet = pAnimationSet;
extractDesc.m_flSampleRateHz = sfmGenInfo.m_flSampleRateHz;
extractDesc.m_flSampleFilterSize = sfmGenInfo.m_flSampleFilterSize;
extractDesc.m_WorkList.AddToTail( extractInfo );
BuildFacialControlList( pShot, pAnimationSet, extractDesc.m_ControlList );
sfm_phonemeextractor->Extract( SPEECH_API_LIPSINC, extractDesc, sfmGenInfo.m_bWritePhonemesInWavs );
CExtractInfo &results = extractDesc.m_WorkList[ 0 ];
CDmElement *pExtractionSettings = pGameSound->FindOrAddPhonemeExtractionSettings();
pExtractionSettings->SetValue< float >( "duration", results.m_flDuration );
// Store off phonemes
if ( !pExtractionSettings->HasAttribute( "results" ) )
{
pExtractionSettings->AddAttribute( "results", AT_ELEMENT_ARRAY );
}
CDmrElementArray< CDmElement > resultsArray( pExtractionSettings, "results" );
resultsArray.RemoveAll();
for ( int i = 0; i < results.m_ApplyTags.Count(); ++i )
{
CBasePhonemeTag *tag = results.m_ApplyTags[ i ];
CDmElement *tagElement = CreateElement< CDmElement >( ConvertPhoneme( tag->GetPhonemeCode() ), pGameSound->GetFileId() );
tagElement->SetValue< float >( "start", tag->GetStartTime() );
tagElement->SetValue< float >( "end", tag->GetEndTime() );
resultsArray.AddToTail( tagElement );
}
if ( pExportFacPath )
{
char pFACFileName[MAX_PATH];
Q_ComposeFileName( pExportFacPath, info.m_DMXFileName, pFACFileName, sizeof(pFACFileName) );
Q_SetExtension( pFACFileName, ".dmx", sizeof(pFACFileName) );
ExportFacialAnimation( pFACFileName, pMovie, pShot, pAnimationSet );
}
}
SaveSFMFile( session.Root(), pOutputDirectory, info.m_DMXFileName );
session.Shutdown();
}
void Correlate( CUtlRBTree< ReferencedFile, int >& referencedfiles, CUtlVector< FileEntry >& contentfiles, const char *modname )
{
int i;
int c = contentfiles.Count();
double totalDiskSize = 0;
double totalReferencedDiskSize = 0;
double totalWhiteListDiskSize = 0;
for ( i = 0; i < c; ++i )
{
totalDiskSize += contentfiles [ i ].size;
}
vprint( 0, "Content tree size on disk %s\n", Q_pretifymem( totalDiskSize, 3 ) );
// Analysis is to walk tree and see which files on disk are referenced in the .lst files
// Need a fast lookup from file symbol to referenced list
CUtlRBTree< ReferencedFile, int > tree( 0, 0, ReferencedFileLessFunc );
c = referencedfiles.Count();
for ( i = 0 ; i < c; ++i )
{
tree.Insert( referencedfiles[ i ] );
}
// Now walk the on disk file and see check off resources which are in referenced
c = contentfiles.Count();
int invalidindex = tree.InvalidIndex();
unsigned int refcounted = 0;
unsigned int whitelisted = 0;
filesystem->RemoveFile( CFmtStr( "%swhitelist.lst", g_szReslistDir ), "GAME" );
for ( i = 0; i < c; ++i )
{
FileEntry & entry = contentfiles[ i ];
ReferencedFile foo;
foo.sym = entry.sym;
bool gameref = tree.Find( foo ) != invalidindex;
char const *fn = g_Analysis.symbols.String( entry.sym );
bool whitelist = g_WhiteList.Find( entry.sym ) != g_WhiteList.InvalidIndex();
if ( gameref || whitelist )
{
entry.referenced = gameref ? REFERENCED_GAME : REFERENCED_WHITELIST;
totalReferencedDiskSize += entry.size;
if ( entry.referenced == REFERENCED_WHITELIST )
{
logprint( CFmtStr( "%swhitelist.lst", g_szReslistDir ), "\"%s\\%s\"\n", modname, fn );
totalWhiteListDiskSize += entry.size;
++whitelisted;
}
++refcounted;
}
}
vprint( 0, "Found %i referenced (%i whitelist) files in tree, %s\n", refcounted, whitelisted, Q_pretifymem( totalReferencedDiskSize, 2 ) );
vprint( 0, "%s appear unused\n", Q_pretifymem( totalDiskSize - totalReferencedDiskSize, 2 ) );
// Now sort and dump the unreferenced ones..
vprint( 0, "Sorting unreferenced files list...\n" );
CUtlRBTree< FileEntry, int > unreftree( 0, 0, FileEntryLessFunc );
for ( i = 0; i < c; ++i )
{
FileEntry & entry = contentfiles[ i ];
if ( entry.referenced != REFERENCED_NO )
continue;
unreftree.Insert( entry );
}
// Now walk the unref tree in order
i = unreftree.FirstInorder();
invalidindex = unreftree.InvalidIndex();
int index = 0;
while ( i != invalidindex )
{
FileEntry & entry = unreftree[ i ];
if ( showreferencedfiles )
{
vprint( 1, "%6i %12s: %s\n", ++index, Q_pretifymem( entry.size, 2 ), g_Analysis.symbols.String( entry.sym ) );
}
i = unreftree.NextInorder( i );
}
if ( showmapfileusage )
{
vprint( 0, "Writing referenced.csv...\n" );
// Now walk the list of referenced files and print out how many and which maps reference them
i = tree.FirstInorder();
invalidindex = tree.InvalidIndex();
index = 0;
while ( i != invalidindex )
{
ReferencedFile & entry = tree[ i ];
char ext[ 32 ];
Q_ExtractFileExtension( g_Analysis.symbols.String( entry.sym ), ext, sizeof( ext ) );
logprint( "referenced.csv", "\"%s\",\"%s\",%d", g_Analysis.symbols.String( entry.sym ), ext, entry.maplist.Count() );
int mapcount = entry.maplist.Count();
for ( int j = 0 ; j < mapcount; ++j )
{
char basemap[ 128 ];
Q_FileBase( g_Analysis.symbols.String( entry.maplist[ j ] ), basemap, sizeof( basemap ) );
logprint( "referenced.csv", ",\"%s\"", basemap );
}
logprint( "referenced.csv", "\n" );
i = tree.NextInorder( i );
}
}
vprint( 0, "\nBuilding directory summary list...\n" );
// Now build summaries by root branch off of gamedir (e.g., for sound, materials, models, etc.)
CUtlDict< DirEntry, int > directories;
invalidindex = directories.InvalidIndex();
for ( i = 0; i < c; ++i )
{
FileEntry & entry = contentfiles[ i ];
// Get the dir name
char const *dirname = g_Analysis.symbols.String( entry.sym );
const char *backslash = strstr( dirname, "\\" );
char dir[ 256 ];
if ( !backslash )
{
dir[0] = 0;
}
else
{
Q_strncpy( dir, dirname, backslash - dirname + 1);
}
int idx = directories.Find( dir );
if ( idx == invalidindex )
{
DirEntry foo;
idx = directories.Insert( dir, foo );
}
DirEntry & de = directories[ idx ];
de.total += entry.size;
if ( entry.referenced == REFERENCED_NO )
{
de.unreferenced += entry.size;
}
if ( entry.referenced == REFERENCED_WHITELIST )
{
de.whitelist += entry.size;
}
}
if ( spewdeletions )
{
// Spew deletion commands to console
if ( immediatedelete )
{
vprint( 0, "\n\nDeleting files...\n" );
}
else
{
vprint( 0, "\n\nGenerating deletions.bat\n" );
}
i = unreftree.FirstInorder();
invalidindex = unreftree.InvalidIndex();
float deletionSize = 0.0f;
int deletionCount = 0;
while ( i != invalidindex )
{
FileEntry & entry = unreftree[ i ];
i = unreftree.NextInorder( i );
// Don't delete stuff that's in the white list
if ( g_WhiteList.Find( entry.sym ) != g_WhiteList.InvalidIndex() )
{
if ( verbose )
{
vprint( 0, "whitelist blocked deletion of %s\n", g_Analysis.symbols.String( entry.sym ) );
}
continue;
}
++deletionCount;
deletionSize += entry.size;
if ( immediatedelete )
{
if ( _chmod( g_Analysis.symbols.String( entry.sym ), _S_IWRITE ) == -1 )
{
vprint( 0, "Could not find file %s\n", g_Analysis.symbols.String( entry.sym ) );
}
if ( _unlink( g_Analysis.symbols.String( entry.sym ) ) == -1 )
{
vprint( 0, "Could not delete file %s\n", g_Analysis.symbols.String( entry.sym ) );
}
if ( deletionCount % 1000 == 0 )
{
vprint( 0, "...deleted %i files\n", deletionCount );
}
}
else
{
logprint( "deletions.bat", "del \"%s\" /f\n", g_Analysis.symbols.String( entry.sym ) );
}
}
vprint( 0, "\nFile deletion (%d files, %s)\n\n", deletionCount, Q_pretifymem(deletionSize, 2) );
}
double grand_total = 0;
double grand_total_unref = 0;
double grand_total_white = 0;
char totalstring[ 20 ];
char unrefstring[ 20 ];
char refstring[ 20 ];
char whiteliststring[ 20 ];
vprint( 0, "---------------------------------------- Summary ----------------------------------------\n" );
vprint( 0, "% 15s % 15s % 15s % 15s %12s\n",
"Referenced",
"WhiteListed",
"Unreferenced",
"Total",
"Directory" );
// Now walk the dictionary in order
i = directories.First();
while ( i != invalidindex )
{
DirEntry & de = directories[ i ];
double remainder = de.total - de.unreferenced;
float percent_unref = 0.0f;
float percent_white = 0.0f;
if ( de.total > 0 )
{
percent_unref = 100.0f * (float)de.unreferenced / (float)de.total;
percent_white = 100.0f * (float)de.whitelist / (float)de.total;
}
Q_strncpy( totalstring, Q_pretifymem( de.total, 2 ), sizeof( totalstring ) );
Q_strncpy( unrefstring, Q_pretifymem( de.unreferenced, 2 ), sizeof( unrefstring ) );
Q_strncpy( refstring, Q_pretifymem( remainder, 2 ), sizeof( refstring ) );
Q_strncpy( whiteliststring, Q_pretifymem( de.whitelist, 2 ), sizeof( whiteliststring ) );
vprint( 0, "%15s (%8.3f%%) %15s (%8.3f%%) %15s (%8.3f%%) %15s => dir: %s\n",
refstring, 100.0f - percent_unref, whiteliststring, percent_white, unrefstring, percent_unref, totalstring, directories.GetElementName( i ) );
grand_total += de.total;
grand_total_unref += de.unreferenced;
grand_total_white += de.whitelist;
i = directories.Next( i );
}
Q_strncpy( totalstring, Q_pretifymem( grand_total, 2 ), sizeof( totalstring ) );
Q_strncpy( unrefstring, Q_pretifymem( grand_total_unref, 2 ), sizeof( unrefstring ) );
Q_strncpy( refstring, Q_pretifymem( grand_total - grand_total_unref, 2 ), sizeof( refstring ) );
Q_strncpy( whiteliststring, Q_pretifymem( grand_total_white, 2 ), sizeof( whiteliststring ) );
double percent_unref = 100.0 * grand_total_unref / grand_total;
double percent_white = 100.0 * grand_total_white / grand_total;
vprint( 0, "-----------------------------------------------------------------------------------------\n" );
vprint( 0, "%15s (%8.3f%%) %15s (%8.3f%%) %15s (%8.3f%%) %15s\n",
refstring, 100.0f - percent_unref, whiteliststring, percent_white, unrefstring, percent_unref, totalstring );
}
