NetworkedClass::~NetworkedClass()
{
if( m_pServerClass )
{
m_pServerClass->m_bFree = true;
m_pServerClass->SetupServerClass(PN_NONE);
unsigned short lookup = m_ServerClassInfoDatabase.Find( m_pNetworkName );
if ( lookup != m_ServerClassInfoDatabase.InvalidIndex() )
{
m_ServerClassInfoDatabase.Remove( m_pNetworkName );
}
}
free( (void *)m_pNetworkName );
m_pNetworkName = NULL;
}
void CClassMap::Add( const char *mapname, const char *classname, int size, DISPATCHFUNCTION factory = 0 )
{
const char *map = Lookup( classname );
if ( map && !Q_strcasecmp( mapname, map ) )
return;
if ( map )
{
int index = m_ClassDict.Find( classname );
Assert( index != m_ClassDict.InvalidIndex() );
m_ClassDict.RemoveAt( index );
}
classentry_t element;
element.SetMapName( mapname );
element.factory = factory;
element.size = size;
m_ClassDict.Insert( classname, element );
}
/**
* Try to look up named sequences in a CUtlDict cache before falling back to the normal LookupSequence. It's
* best to avoid the normal LookupSequence when your models have 750+ sequences...
*/
int CCSPlayerAnimState::CalcSequenceIndex( const char *pBaseName, ... )
{
VPROF( "CCSPlayerAnimState::CalcSequenceIndex" );
CheckCachedSequenceValidity();
char szFullName[512];
va_list marker;
va_start( marker, pBaseName );
Q_vsnprintf( szFullName, sizeof( szFullName ), pBaseName, marker );
va_end( marker );
int iSequence = m_namedSequence.Find( szFullName );
if ( iSequence == m_namedSequence.InvalidIndex() )
{
iSequence = GetOuter()->LookupSequence( szFullName );
m_namedSequence.Insert( szFullName, iSequence );
}
else
{
iSequence = m_namedSequence[iSequence];
}
#if defined(CLIENT_DLL) && defined(_DEBUG)
int realSequence = GetOuter()->LookupSequence( szFullName );
Assert( realSequence == iSequence );
#endif
// Show warnings if we can't find anything here.
if ( iSequence == -1 )
{
static CUtlDict<int,int> dict;
if ( dict.Find( szFullName ) == -1 )
{
dict.Insert( szFullName, 0 );
Warning( "CalcSequenceIndex: can't find '%s'.\n", szFullName );
}
iSequence = 0;
}
return iSequence;
}
//-----------------------------------------------------------------------------
// Restore just the render targets (cause we've got video memory again)
//-----------------------------------------------------------------------------
void CTextureManager::RestoreRenderTargets()
{
// 360 should not have gotten here
Assert( !IsX360() );
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
if ( m_TextureList[i]->IsRenderTarget() )
{
RestoreTexture( m_TextureList[i] );
}
}
if ( m_pFullScreenTexture )
{
g_pShaderAPI->SetFullScreenTextureHandle( m_pFullScreenTexture->GetTextureHandle( 0 ) );
}
CacheExternalStandardRenderTargets();
}
void CTextureManager::AddTextureAlias( const char *pAlias, const char *pRealName )
{
if ( (pAlias == NULL) || (pRealName == NULL) )
return; //invalid alias
char szCleanName[MAX_PATH];
int index = m_TextureAliases.Find( NormalizeTextureName( pAlias, szCleanName, sizeof( szCleanName ) ) );
if ( index != m_TextureAliases.InvalidIndex() )
{
AssertMsg( Q_stricmp( pRealName, m_TextureAliases[index] ) == 0, "Trying to use one name to alias two different textures." );
RemoveTextureAlias( pAlias ); //remove the old alias to make room for the new one.
}
size_t iRealNameLength = strlen( pRealName ) + 1;
char *pRealNameCopy = new char [iRealNameLength];
memcpy( pRealNameCopy, pRealName, iRealNameLength );
m_TextureAliases.Insert( szCleanName, pRealNameCopy );
}
//-----------------------------------------------------------------------------
// Reloads all textures
//-----------------------------------------------------------------------------
void CTextureManager::ForceAllTexturesIntoHardware( void )
{
if ( IsX360() )
return;
IMaterial *pMaterial = MaterialSystem()->FindMaterial( "engine/preloadtexture", "texture preload" );
pMaterial = ((IMaterialInternal *)pMaterial)->GetRealTimeVersion(); //always work with the realtime material internally
bool bFound;
IMaterialVar *pBaseTextureVar = pMaterial->FindVar( "$basetexture", &bFound );
if( !bFound )
{
return;
}
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// Put the texture back onto the board
ForceTextureIntoHardware( m_TextureList[i], pMaterial, pBaseTextureVar );
}
}
void CGECreateServer::AddWeaponSet( const char *group, KeyValues *set )
{
int grpIdx = m_WeaponSets.Find( group );
if ( grpIdx == m_WeaponSets.InvalidIndex() )
grpIdx = m_WeaponSets.Insert( group, new CUtlDict<char*, int>() );
char *name = new char[32];
Q_strncpy( name, set->GetString("print_name", "Unnamed"), 32 );
int setIdx = m_WeaponSets[grpIdx]->Find( set->GetName() );
if ( setIdx != m_WeaponSets[grpIdx]->InvalidIndex() )
{
// Replace the existing set with this one
delete [] m_WeaponSets[grpIdx]->Element(setIdx);
m_WeaponSets[grpIdx]->RemoveAt(grpIdx);
}
// Insert the set
m_WeaponSets[grpIdx]->Insert( set->GetName(), name );
}
void Draw_DecalSetName( int decal, char *name )
{
while ( decal >= g_DecalLookup.Count() )
{
int idx = g_DecalLookup.AddToTail();
g_DecalLookup[ idx ] = 0;
}
int lookup = g_DecalDictionary.Find( name );
if ( lookup == g_DecalDictionary.InvalidIndex() )
{
DecalEntry entry;
entry.material = GL_LoadMaterial( name );
entry.index = decal;
lookup = g_DecalDictionary.Insert( name, entry );
}
g_DecalLookup[ decal ] = lookup;
}
void CTextureManager::RemoveUnusedTextures( void )
{
int iNext;
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = iNext )
{
iNext = m_TextureList.Next( i );
#ifdef _DEBUG
if ( m_TextureList[i]->GetReferenceCount() < 0 )
{
Warning( "RemoveUnusedTextures: pTexture->m_referenceCount < 0 for %s\n", m_TextureList[i]->GetName() );
}
#endif
if ( m_TextureList[i]->GetReferenceCount() <= 0 )
{
ITextureInternal::Destroy( m_TextureList[i] );
m_TextureList.RemoveAt( i );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *decalname -
// Output : int
//-----------------------------------------------------------------------------
int CDecalEmitterSystem::GetDecalIndexForName( char const *decalname )
{
if ( !decalname || !decalname[ 0 ] )
return -1;
int idx = m_Decals.Find( decalname );
if ( idx == m_Decals.InvalidIndex() )
return -1;
DecalEntry *e = &m_Decals[ idx ];
Assert( e );
int count = e->indices.Count();
if ( count <= 0 )
return -1;
float totalweight = 0.0f;
int slot = 0;
for ( int i = 0; i < count; i++ )
{
int idx = e->indices[ i ];
DecalListEntry *item = &m_AllDecals[ idx ];
Assert( item );
if ( !totalweight )
{
slot = idx;
}
// Always assume very first slot will match
totalweight += item->weight;
if ( !totalweight || random->RandomFloat(0,totalweight) < item->weight )
{
slot = idx;
}
}
return m_AllDecals[ slot ].precache_index;
}
void CClassMap::PyAdd( const char *mapname, const char *classname, int size, PyEntityFactory *factory )
{
if( !factory )
return;
const char *map = Lookup( classname );
if ( map && !Q_strcasecmp( mapname, map ) )
return;
if ( map )
{
int index = m_ClassDict.Find( classname );
Assert( index != m_ClassDict.InvalidIndex() );
m_ClassDict.RemoveAt( index );
}
classentry_t element;
element.SetMapName( mapname );
element.pyfactory = factory;
element.size = size;
m_ClassDict.Insert( classname, element );
}
//-----------------------------------------------------------------------------
// Purpose: Find a free PyServerClass and claim it
// Send a message to the clients to claim a client class and set it to
// the right type.
//-----------------------------------------------------------------------------
NetworkedClass::NetworkedClass( const char *pNetworkName, boost::python::object cls_type )
{
m_pNetworkName = strdup( pNetworkName );
m_pServerClass = NULL;
PyServerClass *p;
// See if there is already an entity with this network name
unsigned short lookup = m_ServerClassInfoDatabase.Find( pNetworkName );
if ( lookup != m_ServerClassInfoDatabase.InvalidIndex() )
{
Warning("NetworkedClass: %s already added. Replacing with new data. Element name: %s\n", pNetworkName, m_ServerClassInfoDatabase.Element(lookup) );
p = FindPyServerClass( m_ServerClassInfoDatabase.Element(lookup) );
if( !p )
{
Warning("NetworkedClass: ServerClass %s not found\n", m_ServerClassInfoDatabase.Element(lookup) );
return;
}
if( p->m_pNetworkedClass )
p->m_pNetworkedClass->m_pServerClass = NULL;
}
else
{
// Find a free server class and add it to the database
p = FindFreePyServerClass();
if( !p ) {
Warning("Couldn't create PyServerClass %s: Out of free PyServerClasses\n", pNetworkName);
return;
}
lookup = m_ServerClassInfoDatabase.Insert(pNetworkName, p->GetName());
}
m_pServerClass = p;
m_PyClass = cls_type;
p->m_bFree = false;
p->m_pNetworkedClass = this;
SetupServerClass();
}
int CTextureManager::FindNext( int iIndex, ITextureInternal **pTexInternal )
{
if ( iIndex == -1 && m_TextureList.Count() )
{
iIndex = m_TextureList.First();
}
else if ( !m_TextureList.Count() || !m_TextureList.IsValidIndex( iIndex ) )
{
*pTexInternal = NULL;
return -1;
}
*pTexInternal = m_TextureList[iIndex];
iIndex = m_TextureList.Next( iIndex );
if ( iIndex == m_TextureList.InvalidIndex() )
{
// end of list
iIndex = -1;
}
return iIndex;
}
NetworkedClass::~NetworkedClass()
{
unsigned short lookup;
// Remove pointer
lookup = m_NetworkClassDatabase.Find( m_pNetworkName );
if ( lookup != m_NetworkClassDatabase.InvalidIndex() )
{
// Only remove if it's our pointer. Otherwise we are already replaced.
if( m_NetworkClassDatabase.Element( lookup ) == this )
m_NetworkClassDatabase.RemoveAt( lookup );
}
else
{
Warning("NetworkedClass destruction: invalid networkclass %s\n", m_pNetworkName);
}
if( m_pClientClass )
{
m_pClientClass->m_bFree = true;
}
free( (void *)m_pNetworkName );
m_pNetworkName = NULL;
}
void ProcessVCD( CUtlDict< VCDList, int >& database, CUtlSymbol& vcdname )
{
// vprint( 0, "Processing '%s'\n", g_Analysis.symbols.String( vcdname ) );
// Load the .vcd
char fullname[ 512 ];
Q_snprintf( fullname, sizeof( fullname ), "%s", g_Analysis.symbols.String( vcdname ) );
LoadScriptFile( fullname );
CChoreoScene *scene = ChoreoLoadScene( fullname, NULL, &g_TokenProcessor, Con_Printf );
if ( scene )
{
bool first = true;
// Now iterate the events looking for speak events
int c = scene->GetNumEvents();
for ( int i = 0; i < c; i++ )
{
CChoreoEvent *e = scene->GetEvent( i );
if ( e->GetType() == CChoreoEvent::MOVETO )
{
SpewMoveto( first, fullname, e );
first = false;
}
if ( e->GetType() != CChoreoEvent::SPEAK )
continue;
// Look up sound in sound emitter system
char const *wavename = soundemitter->GetWavFileForSound( e->GetParameters(), NULL );
if ( !wavename || !wavename[ 0 ] )
{
continue;
}
char fullwavename[ 512 ];
Q_snprintf( fullwavename, sizeof( fullwavename ), "%ssound\\%s",
gamedir, wavename );
Q_FixSlashes( fullwavename );
// Now add to proper slot
VCDList *entry = NULL;
// Add vcd to database
int slot = database.Find( fullwavename );
if ( slot == database.InvalidIndex() )
{
VCDList nullEntry;
slot = database.Insert( fullwavename, nullEntry );
}
entry = &database[ slot ];
if ( entry->vcds.Find( vcdname ) == entry->vcds.InvalidIndex() )
{
entry->vcds.AddToTail( vcdname );
}
}
if ( vcdonly )
{
CheckForOverlappingFlexTracks( scene );
}
}
delete scene;
}
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 );
}
void Cmd_AddClientCmdCanExecuteVar( const char *pName )
{
if ( g_ExtraClientCmdCanExecuteCvars.Find( pName ) == g_ExtraClientCmdCanExecuteCvars.InvalidIndex() )
g_ExtraClientCmdCanExecuteCvars.Insert( pName );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
//-----------------------------------------------------------------------------
void CDecalEmitterSystem::LoadDecalsFromScript( char const *filename )
{
KeyValues *kv = new KeyValues( filename );
Assert( kv );
if ( kv )
{
KeyValues *translation = NULL;
#ifndef _XBOX
if ( kv->LoadFromFile( filesystem, filename ) )
#else
if ( kv->LoadFromFile( filesystem, filename, "GAME" ) )
#endif
{
KeyValues *p = kv;
while ( p )
{
if ( p->GetFirstSubKey() )
{
char const *keyname = p->GetName();
if ( !Q_stricmp( keyname, TRANSLATION_DATA_SECTION ) )
{
translation = p;
}
else
{
DecalEntry entry;
for ( KeyValues *sub = p->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
MEM_ALLOC_CREDIT();
DecalListEntry decal;
decal.precache_index = -1;
decal.name = m_DecalFileNames.AddString( sub->GetName() );
decal.weight = sub->GetFloat();
// Add to global list
int idx = m_AllDecals.AddToTail( decal );
// Add index only to local list
entry.indices.AddToTail( idx );
}
// Add entry to main dictionary
m_Decals.Insert( keyname, entry );
}
}
p = p->GetNextKey();
}
}
else
{
Msg( "CDecalEmitterSystem::LoadDecalsFromScript: Unable to load '%s'\n", filename );
}
if ( !translation )
{
Msg( "CDecalEmitterSystem::LoadDecalsFromScript: Script '%s' missing section '%s'\n",
filename,
TRANSLATION_DATA_SECTION );
}
else
{
// Now parse game material to entry translation table
for ( KeyValues *sub = translation->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
// Don't add NULL string to list
if ( !Q_stricmp( sub->GetString(), "" ) )
continue;
int idx = m_Decals.Find( sub->GetString() );
if ( idx != m_Decals.InvalidIndex() )
{
m_GameMaterialTranslation.Insert( sub->GetName(), idx );
}
else
{
Msg( "CDecalEmitterSystem::LoadDecalsFromScript: Translation for game material type '%s' references unknown decal '%s'\n",
sub->GetName(), sub->GetString() );
}
}
}
kv->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose: A CPointTemplate has asked us to reconnect all the entity I/O links
// inside it's templates. Go through the keys and add look for values
// that match a name within the group's entity names. Append %d to any
// found values, which will later be filled out by a unique identifier
// whenever the template is instanced.
//-----------------------------------------------------------------------------
void Templates_ReconnectIOForGroup( CPointTemplate *pGroup )
{
int iCount = pGroup->GetNumTemplates();
if ( !iCount )
return;
// First assemble a list of the targetnames of all the templates in the group.
// We need to store off the original names here, because we're going to change
// them as we go along.
CUtlVector< grouptemplate_t > GroupTemplates;
int i;
for ( i = 0; i < iCount; i++ )
{
grouptemplate_t newGroupTemplate;
newGroupTemplate.iIndex = pGroup->GetTemplateIndexForTemplate(i);
newGroupTemplate.pMapDataParser = new CEntityMapData( g_Templates[ newGroupTemplate.iIndex ]->pszMapData, g_Templates[ newGroupTemplate.iIndex ]->iMapDataLength );
Assert( newGroupTemplate.pMapDataParser );
newGroupTemplate.pMapDataParser->ExtractValue( "targetname", newGroupTemplate.pszName );
newGroupTemplate.bChangeTargetname = false;
GroupTemplates.AddToTail( newGroupTemplate );
}
if (pGroup->AllowNameFixup())
{
char keyName[MAPKEY_MAXLENGTH];
char value[MAPKEY_MAXLENGTH];
char valueclipped[MAPKEY_MAXLENGTH];
// Now go through all the entities in the group and parse their mapdata keyvalues.
// We're looking for any values that match targetnames of any of the group entities.
for ( i = 0; i < iCount; i++ )
{
// We need to know what instance of each key we're changing.
// Store a table of the count of the keys we've run into.
CUtlDict< int, int > KeyInstanceCount;
CEntityMapData *mapData = GroupTemplates[i].pMapDataParser;
// Loop through our keys
if ( !mapData->GetFirstKey(keyName, value) )
continue;
do
{
// Ignore targetnames
if ( !stricmp( keyName, "targetname" ) )
continue;
// Add to the count for this
int idx = KeyInstanceCount.Find( keyName );
if ( idx == KeyInstanceCount.InvalidIndex() )
{
idx = KeyInstanceCount.Insert( keyName, 0 );
}
KeyInstanceCount[idx]++;
// Entity I/O values are stored as "Targetname,<data>", so we need to see if there's a ',' in the string
char *sValue = value;
// FIXME: This is very brittle. Any key with a , will not be found.
char *s = strchr( value, ',' );
if ( s )
{
// Grab just the targetname of the receiver
Q_strncpy( valueclipped, value, (s - value+1) );
sValue = valueclipped;
}
// Loop through our group templates
for ( int iTName = 0; iTName < iCount; iTName++ )
{
char *pName = GroupTemplates[iTName].pszName;
if ( stricmp( pName, sValue ) )
continue;
if ( template_debug.GetInt() )
{
Msg("Template Connection Found: Key %s (\"%s\") in entity named \"%s\"(%d) matches entity %d's targetname\n", keyName, sValue, GroupTemplates[i].pszName, i, iTName );
}
char newvalue[MAPKEY_MAXLENGTH];
// Get the current key instance. (-1 because it's this one we're changing)
int nKeyInstance = KeyInstanceCount[idx] - 1;
// Add our IO value to the targetname
// We need to append it if this isn't an Entity I/O value, or prepend it to the ',' if it is
if ( s )
{
Q_strncpy( newvalue, valueclipped, MAPKEY_MAXLENGTH );
Q_strncat( newvalue, ENTITYIO_FIXUP_STRING, sizeof(newvalue), COPY_ALL_CHARACTERS );
Q_strncat( newvalue, s, sizeof(newvalue), COPY_ALL_CHARACTERS );
mapData->SetValue( keyName, newvalue, nKeyInstance );
}
else
{
Q_strncpy( newvalue, sValue, MAPKEY_MAXLENGTH );
Q_strncat( newvalue, ENTITYIO_FIXUP_STRING, sizeof(newvalue), COPY_ALL_CHARACTERS );
mapData->SetValue( keyName, newvalue, nKeyInstance );
}
// Remember we changed this targetname
GroupTemplates[iTName].bChangeTargetname = true;
// Set both entity's flags telling them their template needs fixup when it's spawned
g_Templates[ GroupTemplates[i].iIndex ]->bNeedsEntityIOFixup = true;
g_Templates[ GroupTemplates[iTName].iIndex ]->bNeedsEntityIOFixup = true;
}
}
while ( mapData->GetNextKey(keyName, value) );
}
// Now change targetnames for all entities that need them changed
for ( i = 0; i < iCount; i++ )
{
char value[MAPKEY_MAXLENGTH];
if ( GroupTemplates[i].bChangeTargetname )
{
CEntityMapData *mapData = GroupTemplates[i].pMapDataParser;
mapData->ExtractValue( "targetname", value );
Q_strncat( value, ENTITYIO_FIXUP_STRING, sizeof(value), COPY_ALL_CHARACTERS );
mapData->SetValue( "targetname", value );
}
}
}
// Delete our group parsers
for ( i = 0; i < iCount; i++ )
{
delete GroupTemplates[i].pMapDataParser;
}
GroupTemplates.Purge();
}
void CClassMap::PyRemove( const char *classname )
{
int index = m_ClassDict.Find( classname );
Assert( index != m_ClassDict.InvalidIndex() );
m_ClassDict.RemoveAt( index );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : ITEM_FILE_INFO_HANDLE
//-----------------------------------------------------------------------------
ITEM_FILE_INFO_HANDLE GetInvalidItemInfoHandle( void )
{
return (ITEM_FILE_INFO_HANDLE)m_ItemInfoDatabase.InvalidIndex();
}
void CTextureManager::SetExcludedTextures( const char *pScriptName )
{
// clear all exisiting texture's exclusion
for ( int i = m_TextureExcludes.First(); i != m_TextureExcludes.InvalidIndex(); i = m_TextureExcludes.Next( i ) )
{
ITextureInternal *pTexture = FindTexture( m_TextureExcludes.GetElementName( i ) );
if ( pTexture )
{
pTexture->MarkAsExcluded( false, 0 );
}
}
m_TextureExcludes.RemoveAll();
MEM_ALLOC_CREDIT();
// get optional script
CUtlBuffer excludeBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( g_pFullFileSystem->ReadFile( pScriptName, NULL, excludeBuffer ) )
{
char szToken[MAX_PATH];
while ( 1 )
{
// must support spaces in names without quotes
// have to brute force parse up to a valid line
while ( 1 )
{
excludeBuffer.EatWhiteSpace();
if ( !excludeBuffer.EatCPPComment() )
{
// not a comment
break;
}
}
excludeBuffer.GetLine( szToken, sizeof( szToken ) );
int tokenLength = strlen( szToken );
if ( !tokenLength )
{
// end of list
break;
}
// remove all trailing whitespace
while ( tokenLength > 0 )
{
tokenLength--;
if ( isgraph( szToken[tokenLength] ) )
{
break;
}
szToken[tokenLength] = '\0';
}
// first optional token may be a dimension limit hint
int nDimensionsLimit = 0;
char *pTextureName = szToken;
if ( pTextureName[0] != 0 && isdigit( pTextureName[0] ) )
{
nDimensionsLimit = atoi( pTextureName );
// skip forward to name
for ( ;; )
{
char ch = *pTextureName;
if ( !ch || ( !isdigit( ch ) && !isspace( ch ) ) )
{
break;
}
pTextureName++;
}
}
char szCleanName[MAX_PATH];
NormalizeTextureName( pTextureName, szCleanName, sizeof( szCleanName ) );
if ( m_TextureExcludes.Find( szCleanName ) != m_TextureExcludes.InvalidIndex() )
{
// avoid duplicates
continue;
}
m_TextureExcludes.Insert( szCleanName, nDimensionsLimit );
// set any existing texture's exclusion
// textures that don't exist yet will get caught during their creation path
ITextureInternal *pTexture = FindTexture( szCleanName );
if ( pTexture )
{
pTexture->MarkAsExcluded( ( nDimensionsLimit == 0 ), nDimensionsLimit );
}
}
}
}
void CTextureManager::Shutdown()
{
FreeStandardRenderTargets();
// These checks added because it's possible for shutdown to be called before the material system is
// fully initialized.
if ( m_pWhiteTexture )
{
m_pWhiteTexture->DecrementReferenceCount();
m_pWhiteTexture = NULL;
}
if ( m_pBlackTexture )
{
m_pBlackTexture->DecrementReferenceCount();
m_pBlackTexture = NULL;
}
if ( m_pGreyTexture )
{
m_pGreyTexture->DecrementReferenceCount();
m_pGreyTexture = NULL;
}
if ( m_pGreyAlphaZeroTexture )
{
m_pGreyAlphaZeroTexture->DecrementReferenceCount();
m_pGreyAlphaZeroTexture = NULL;
}
if ( m_pNormalizationCubemap )
{
m_pNormalizationCubemap->DecrementReferenceCount();
m_pNormalizationCubemap = NULL;
}
if ( m_pSignedNormalizationCubemap )
{
m_pSignedNormalizationCubemap->DecrementReferenceCount();
m_pSignedNormalizationCubemap = NULL;
}
if ( m_pShadowNoise2D )
{
m_pShadowNoise2D->DecrementReferenceCount();
m_pShadowNoise2D = NULL;
}
if ( m_pIdentityLightWarp )
{
m_pIdentityLightWarp->DecrementReferenceCount();
m_pIdentityLightWarp = NULL;
}
if ( m_pErrorTexture )
{
m_pErrorTexture->DecrementReferenceCount();
m_pErrorTexture = NULL;
}
ReleaseTextures();
if ( m_pErrorRegen )
{
m_pErrorRegen->Release();
m_pErrorRegen = NULL;
}
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
ITextureInternal::Destroy( m_TextureList[i] );
}
m_TextureList.RemoveAll();
for( int i = m_TextureAliases.First(); i != m_TextureAliases.InvalidIndex(); i = m_TextureAliases.Next( i ) )
{
delete []m_TextureAliases[i];
}
m_TextureAliases.RemoveAll();
m_TextureExcludes.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : WEAPON_FILE_INFO_HANDLE
//-----------------------------------------------------------------------------
WEAPON_FILE_INFO_HANDLE GetInvalidWeaponInfoHandle( void )
{
return (WEAPON_FILE_INFO_HANDLE)m_WeaponInfoDatabase.InvalidIndex();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : PLAYERCLASS_FILE_INFO_HANDLE
//-----------------------------------------------------------------------------
PLAYERCLASS_FILE_INFO_HANDLE GetInvalidPlayerClassInfoHandle( void )
{
return (PLAYERCLASS_FILE_INFO_HANDLE)m_PlayerClassInfoDatabase.InvalidIndex();
}
// Compute master/slave, count, endtime info for close captioning data
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoChannel::ReconcileCloseCaption()
{
// Create a dictionary based on the combined token name
CUtlDict< EventGroup, int > validSpeakEventsGroupedByName;
int i;
// Sort items
int c = GetNumEvents();
for ( i = 0; i < c; i++ )
{
CChoreoEvent *e = GetEvent( i );
Assert( e );
if ( e->GetType() != CChoreoEvent::SPEAK )
continue;
CChoreoEvent::CLOSECAPTION type;
type = e->GetCloseCaptionType();
if ( type == CChoreoEvent::CC_DISABLED )
{
e->SetUsingCombinedFile( false );
e->SetRequiredCombinedChecksum( 0 );
e->SetNumSlaves( 0 );
e->SetLastSlaveEndTime( 0.0f );
continue;
}
char const *name = e->GetCloseCaptionToken();
if ( !name || !name[0] )
{
// Fixup invalid slave tag
if ( type == CChoreoEvent::CC_SLAVE )
{
e->SetCloseCaptionType( CChoreoEvent::CC_MASTER );
e->SetUsingCombinedFile( false );
e->SetRequiredCombinedChecksum( 0 );
e->SetNumSlaves( 0 );
e->SetLastSlaveEndTime( 0.0f );
}
continue;
}
int idx = validSpeakEventsGroupedByName.Find( name );
if ( idx == validSpeakEventsGroupedByName.InvalidIndex() )
{
EventGroup eg;
eg.timeSortedEvents.Insert( e );
validSpeakEventsGroupedByName.Insert( name, eg );
}
else
{
EventGroup & eg = validSpeakEventsGroupedByName[ idx ];
eg.timeSortedEvents.Insert( e );
}
}
c = validSpeakEventsGroupedByName.Count();
// Now walk list of events by group
if ( !c )
{
return;
}
for ( i = 0; i < c; ++i )
{
EventGroup & eg = validSpeakEventsGroupedByName[ i ];
int sortedEventInGroup = eg.timeSortedEvents.Count();
// If there's only one, just mark it valid
if ( sortedEventInGroup <= 1 )
{
CChoreoEvent *e = eg.timeSortedEvents[ 0 ];
Assert( e );
// Make sure it's the master
e->SetCloseCaptionType( CChoreoEvent::CC_MASTER );
// Since it's by itself, can't be using "combined" file
e->SetUsingCombinedFile( false );
e->SetRequiredCombinedChecksum( 0 );
e->SetNumSlaves( 0 );
e->SetLastSlaveEndTime( 0.0f );
continue;
}
// Okay, read them back in of start time
int j = eg.timeSortedEvents.FirstInorder();
CChoreoEvent *master = NULL;
while ( j != eg.timeSortedEvents.InvalidIndex() )
{
CChoreoEvent *e = eg.timeSortedEvents[ j ];
if ( !master )
{
master = e;
e->SetCloseCaptionType( CChoreoEvent::CC_MASTER );
//e->SetUsingCombinedFile( true );
e->SetRequiredCombinedChecksum( 0 );
e->SetNumSlaves( sortedEventInGroup - 1 );
e->SetLastSlaveEndTime( e->GetEndTime() );
}
else
{
// Keep bumping out the end time
master->SetLastSlaveEndTime( e->GetEndTime() );
e->SetCloseCaptionType( CChoreoEvent::CC_SLAVE );
e->SetUsingCombinedFile( master->IsUsingCombinedFile() );
e->SetRequiredCombinedChecksum( 0 );
e->SetLastSlaveEndTime( 0.0f );
}
j = eg.timeSortedEvents.NextInorder( j );
}
}
}
