//--------------------------------------------------------------------------------------------------------------
void CCSPlayerAnimState::CheckCachedSequenceValidity( void )
{
if ( m_cachedModelIndex != GetOuter()->GetModelIndex() )
{
m_namedSequence.RemoveAll();
m_cachedModelIndex = GetOuter()->GetModelIndex();
for ( int i=0; i<=ACT_CROUCHIDLE; ++i )
{
m_sequenceCache[i] = -1;
}
// precache the sequences we'll be using for movement
if ( m_cachedModelIndex > 0 )
{
m_sequenceCache[ACT_HOP - 1] = GetOuter()->SelectWeightedSequence( ACT_HOP );
m_sequenceCache[ACT_IDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_IDLE );
m_sequenceCache[ACT_RUN_CROUCH - 1] = GetOuter()->SelectWeightedSequence( ACT_RUN_CROUCH );
m_sequenceCache[ACT_CROUCHIDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_CROUCHIDLE );
m_sequenceCache[ACT_RUN - 1] = GetOuter()->SelectWeightedSequence( ACT_RUN );
m_sequenceCache[ACT_WALK - 1] = GetOuter()->SelectWeightedSequence( ACT_WALK );
m_sequenceCache[ACT_IDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_IDLE );
}
}
}
void ResetTriggerFactoryDatabase( void )
{
for ( int i=m_TriggerFactoryDatabase.First(); i != m_TriggerFactoryDatabase.InvalidIndex(); i=m_TriggerFactoryDatabase.Next( i ) )
{
delete m_TriggerFactoryDatabase[ i ];
}
m_TriggerFactoryDatabase.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : * -
// list -
//-----------------------------------------------------------------------------
void FreeHudTextureList(CUtlDict< CHudTexture *, int >& list)
{
int c = list.Count();
for (int i = 0; i < c; i++)
{
CHudTexture *tex = list[i];
delete tex;
}
list.RemoveAll();
}
void ResetFileWeaponInfoDatabase( void )
{
int c = m_WeaponInfoDatabase.Count();
for ( int i = 0; i < c; ++i )
{
delete m_WeaponInfoDatabase[ i ];
}
m_WeaponInfoDatabase.RemoveAll();
#ifdef _DEBUG
memset(g_bUsedWeaponSlots, 0, sizeof(g_bUsedWeaponSlots));
#endif
}
void ResetEntityFactoryDatabase( void )
{
#ifdef CLIENT_DLL
#ifdef LUA_SDK
GetClassMap().RemoveAllScripted();
#endif
#else
for ( int i=m_EntityFactoryDatabase.First(); i != m_EntityFactoryDatabase.InvalidIndex(); i=m_EntityFactoryDatabase.Next( i ) )
{
delete m_EntityFactoryDatabase[ i ];
}
m_EntityFactoryDatabase.RemoveAll();
#endif
}
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();
}
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 CMapEntities::CheckUpdateMap( char const *mapname )
{
if ( !mapname || !mapname[ 0 ] )
return;
if ( !stricmp( mapname, m_szCurrentMap ) )
return;
// Latch off the name of the map
Q_strncpy( m_szCurrentMap, mapname, sizeof( m_szCurrentMap ) );
// Load names from map
m_Entities.RemoveAll();
FileHandle_t hfile = filesystem->Open( mapname, "rb" );
if ( hfile == FILESYSTEM_INVALID_HANDLE )
return;
dheader_t header;
filesystem->Read( &header, sizeof( header ), hfile );
// Check the header
if ( header.ident != IDBSPHEADER ||
header.version < MINBSPVERSION || header.version > BSPVERSION )
{
Con_ErrorPrintf( "BSP file %s is wrong version (%i), expected (%i)\n",
mapname,
header.version,
BSPVERSION );
filesystem->Close( hfile );
return;
}
// Find the LUMP_PAKFILE offset
lump_t *entlump = &header.lumps[ LUMP_ENTITIES ];
if ( entlump->filelen <= 0 )
{
Con_ErrorPrintf( "BSP file %s is missing entity lump\n", mapname );
// It's empty or only contains a file header ( so there are no entries ), so don't add to search paths
filesystem->Close( hfile );
return;
}
// Seek to correct position
filesystem->Seek( hfile, entlump->fileofs, FILESYSTEM_SEEK_HEAD );
char *buffer = new char[ entlump->filelen + 1 ];
Assert( buffer );
filesystem->Read( buffer, entlump->filelen, hfile );
filesystem->Close( hfile );
buffer[ entlump->filelen ] = 0;
// Now we have entity buffer, now parse it
ParseFromMemory( buffer, entlump->filelen );
while ( 1 )
{
if (!GetToken (true))
break;
if (Q_stricmp (token, "{") )
Error ("ParseEntity: { not found");
char name[ 256 ];
char origin[ 256 ];
char angles[ 256 ];
name[ 0 ] = 0;
origin[ 0 ] = 0;
angles[ 0 ] = 0;
do
{
char key[ 256 ];
char value[ 256 ];
if (!GetToken (true))
{
Error ("ParseEntity: EOF without closing brace");
}
if (!Q_stricmp (token, "}") )
break;
Q_strncpy( key, token, sizeof( key ) );
GetToken (false);
Q_strncpy( value, token, sizeof( value ) );
// Con_Printf( "Parsed %s -- %s\n", key, value );
if ( !Q_stricmp( key, "name" ) )
{
Q_strncpy( name, value, sizeof( name ) );
}
if ( !Q_stricmp( key, "targetname" ) )
{
Q_strncpy( name, value, sizeof( name ) );
}
if ( !Q_stricmp( key, "origin" ) )
{
Q_strncpy( origin, value, sizeof( origin ) );
}
if ( !Q_stricmp( key, "angles" ) )
{
Q_strncpy( angles, value, sizeof( angles ) );
}
} while (1);
if ( name[ 0 ] )
{
if ( FindNamedEntity( name ) == - 1 )
{
CMapEntityData ent;
float org[3];
if ( origin[ 0 ] )
{
if ( 3 == sscanf( origin, "%f %f %f", &org[ 0 ], &org[ 1 ], &org[ 2 ] ) )
{
ent.origin = Vector( org[ 0 ], org[ 1 ], org[ 2 ] );
// Con_Printf( "read %f %f %f for entity %s\n", org[0], org[1], org[2], name );
}
}
if ( angles[ 0 ] )
{
if ( 3 == sscanf( angles, "%f %f %f", &org[ 0 ], &org[ 1 ], &org[ 2 ] ) )
{
ent.angles = QAngle( org[ 0 ], org[ 1 ], org[ 2 ] );
// Con_Printf( "read %f %f %f for entity %s\n", org[0], org[1], org[2], name );
}
}
m_Entities.Insert( name, ent );
}
}
}
delete[] buffer;
}
// This is called to reset all loaded decals
// called from cl_parse.cpp and host.cpp
void Decal_Init( void )
{
g_DecalDictionary.RemoveAll();
g_DecalLookup.RemoveAll();
}
