//-----------------------------------------------------------------------------
// 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,
const char *pClientModuleName )
{
m_pClientClass = NULL;
m_pNetworkName = strdup( pNetworkName );
m_pyClass = cls_type;
unsigned short lookup = m_NetworkClassDatabase.Find( m_pNetworkName );
if ( lookup != m_NetworkClassDatabase.InvalidIndex() )
{
Warning("NetworkedClass: %s already added, replacing contents...\n", pNetworkName);
m_pClientClass = m_NetworkClassDatabase[lookup]->m_pClientClass;
m_NetworkClassDatabase[lookup] = this;
if( m_pClientClass )
{
AttachClientClass( m_pClientClass );
}
}
else
{
// New entry, add to database and find if there is an existing ClientClass
m_NetworkClassDatabase.Insert( m_pNetworkName, this );
m_pClientClass = FindPyClientClassToNetworkClass( m_pNetworkName );
}
}
void CTextureManager::UpdateExcludedTextures( void )
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
m_TextureList[i]->UpdateExcludedState();
}
}
void CTextureManager::ResetTextureFilteringState( )
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
m_TextureList[i]->SetFilteringAndClampingMode();
}
}
//-----------------------------------------------------------------------------
// Create, destroy panel...
//-----------------------------------------------------------------------------
vgui::Panel *CPanelMetaClassMgrImp::CreatePanelMetaClass( const char* pMetaClassName,
int sortorder, void *pInitData, vgui::Panel *pParent, const char *pChainName )
{
// Search for the metaclass name
int i = m_MetaClassDict.Find( pMetaClassName );
if (i == m_MetaClassDict.InvalidIndex())
return NULL;
// Now that we've got the metaclass, we can figure out what kind of
// panel to instantiate...
MetaClassDict_t &metaClass = m_MetaClassDict[i];
IPanelFactory* pFactory = m_PanelTypeDict[metaClass.m_TypeIndex];
// Set up the key values for use in initialization
if (pChainName)
{
KeyValueChainRecursive( metaClass.m_pKeyValues, pChainName );
}
// Create and initialize the panel
vgui::Panel *pPanel = pFactory->Create( pMetaClassName, metaClass.m_pKeyValues, pInitData, pParent );
if ( pPanel )
{
pPanel->SetZPos( sortorder );
}
return pPanel;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDecalEmitterSystem::Clear()
{
m_DecalFileNames.RemoveAll();
m_Decals.Purge();
m_AllDecals.Purge();
m_GameMaterialTranslation.Purge();
}
virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave )
{
CUtlDict< ConceptHistory_t, int > *ch = ((CUtlDict< ConceptHistory_t, int > *)fieldInfo.pField);
int count = ch->Count();
pSave->WriteInt( &count );
for ( int i = 0 ; i < count; i++ )
{
ConceptHistory_t *pHistory = &(*ch)[ i ];
pSave->StartBlock();
{
// Write element name
pSave->WriteString( ch->GetElementName( i ) );
// Write data
pSave->WriteAll( pHistory );
// Write response blob
bool hasresponse = pHistory->response != NULL ? true : false;
pSave->WriteBool( &hasresponse );
if ( hasresponse )
{
pSave->WriteAll( pHistory->response );
}
// TODO: Could blat out pHistory->criteria pointer here, if it's needed
}
pSave->EndBlock();
}
}
//-----------------------------------------------------------------------------
// Parse a single metaclass
//-----------------------------------------------------------------------------
bool CPanelMetaClassMgrImp::ParseSingleMetaClass( const char* pFileName,
const char* pMetaClassName, KeyValues* pMetaClassValues, int keyValueIndex )
{
// Complain about duplicately defined metaclass names...
if ( m_MetaClassDict.Find( pMetaClassName ) != m_MetaClassDict.InvalidIndex() )
{
Warning( "Meta class %s duplicately defined (file %s)\n", pMetaClassName, pFileName );
return false;
}
// find the type...
const char* pPanelType = pMetaClassValues->GetString( "type" );
if (!pPanelType || !pPanelType[0])
{
Warning( "Unable to find type of meta class %s in file %s\n", pMetaClassName, pFileName );
return false;
}
unsigned short i = m_PanelTypeDict.Find( pPanelType );
if (i == m_PanelTypeDict.InvalidIndex())
{
Warning( "Type %s of meta class %s undefined!\n", pPanelType, pMetaClassName );
stackfree(pLwrMetaClass);
return false;
}
// Add it to the metaclass dictionary
MetaClassDict_t element;
element.m_TypeIndex = i;
element.m_KeyValueIndex = keyValueIndex;
element.m_pKeyValues = pMetaClassValues;
m_MetaClassDict.Insert( pMetaClassName, element );
return true;
}
void RegisterScriptedEntity( const char *className )
{
#ifdef CLIENT_DLL
if ( GetClassMap().FindFactory( className ) )
{
return;
}
GetClassMap().Add( className, "CBaseScripted", sizeof( CBaseScripted ),
&CCBaseScriptedFactory, true );
#else
if ( EntityFactoryDictionary()->FindFactory( className ) )
{
return;
}
unsigned short lookup = m_EntityFactoryDatabase.Find( className );
if ( lookup != m_EntityFactoryDatabase.InvalidIndex() )
{
return;
}
CEntityFactory<CBaseScripted> *pFactory = new CEntityFactory<CBaseScripted>( className );
lookup = m_EntityFactoryDatabase.Insert( className, pFactory );
Assert( lookup != m_EntityFactoryDatabase.InvalidIndex() );
#endif
}
//-----------------------------------------------------------------------------
// Finds a widget factory by name
//-----------------------------------------------------------------------------
IAttributeWidgetFactory *CAttributeWidgetFactoryList::FindWidgetFactory( const char *pWidgetName )
{
unsigned short i = m_Factories.Find( pWidgetName );
if ( i != m_Factories.InvalidIndex() )
return m_Factories[i];
return NULL;
}
char const *CMapEntities::GetName( int number )
{
if ( number < 0 || number >= (int)m_Entities.Count() )
return NULL;
return m_Entities.GetElementName( number );
}
char* AllocateUniqueDataTableName( bool bSendTable, const char *pFormat, ... )
{
// Setup the string.
va_list marker;
va_start( marker, pFormat );
char *pRet = AllocateStringHelper2( pFormat, marker );
va_end( marker );
// Make sure it's unique.
#ifdef _DEBUG
// Have to allocate them here because if they're declared as straight global variables,
// their constructors won't have been called yet by the time we get in here.
if ( !g_STDict )
{
g_STDict = new CUtlDict<int,int>;
g_RTDict = new CUtlDict<int,int>;
}
CUtlDict<int,int> *pDict = bSendTable ? g_STDict : g_RTDict;
if ( pDict->Find( pRet ) != pDict->InvalidIndex() )
{
// If it hits this, then they have 2 utlvectors in different data tables with the same name and the
// same size limit. The names of
Assert( false );
}
pDict->Insert( pRet, 0 );
#endif
return pRet;
}
PyEntityFactory* CClassMap::PyGetFactory( const char *classname )
{
int index = m_ClassDict.Find( classname );
if( index == m_ClassDict.InvalidIndex() )
return NULL;
return m_ClassDict[index].pyfactory;
}
void RegisterScriptedWeapon( const char *className )
{
#ifdef CLIENT_DLL
if ( GetClassMap().FindFactory( className ) )
{
return;
}
GetClassMap().Add( className, "CHL2MPScriptedWeapon", sizeof( CHL2MPScriptedWeapon ),
&CCHL2MPScriptedWeaponFactory, true );
#else
if ( EntityFactoryDictionary()->FindFactory( className ) )
{
return;
}
unsigned short lookup = m_WeaponFactoryDatabase.Find( className );
if ( lookup != m_WeaponFactoryDatabase.InvalidIndex() )
{
return;
}
// Andrew; This fixes months worth of pain and anguish.
CEntityFactory<CHL2MPScriptedWeapon> *pFactory = new CEntityFactory<CHL2MPScriptedWeapon>( className );
lookup = m_WeaponFactoryDatabase.Insert( className, pFactory );
Assert( lookup != m_WeaponFactoryDatabase.InvalidIndex() );
#endif
// BUGBUG: When attempting to precache weapons registered during runtime,
// they don't appear as valid registered entities.
// static CPrecacheRegister precache_weapon_(&CPrecacheRegister::PrecacheFn_Other, className);
}
void DiscoverMacroTextures()
{
CUtlDict<int,int> tempDict;
g_FaceMacroTextureInfos.SetSize( numfaces );
for ( int iFace=0; iFace < numfaces; iFace++ )
{
texinfo_t *pTexInfo = &texinfo[dfaces[iFace].texinfo];
if ( pTexInfo->texdata < 0 )
continue;
dtexdata_t *pTexData = &dtexdata[pTexInfo->texdata];
const char *pMaterialName = &g_TexDataStringData[ g_TexDataStringTable[pTexData->nameStringTableID] ];
MaterialSystemMaterial_t hMaterial = FindMaterial( pMaterialName, NULL, false );
const char *pMacroTextureName = GetMaterialVar( hMaterial, "$macro_texture" );
if ( pMacroTextureName )
{
if ( tempDict.Find( pMacroTextureName ) == tempDict.InvalidIndex() )
{
Msg( "-- DiscoverMacroTextures: %s\n", pMacroTextureName );
tempDict.Insert( pMacroTextureName, 0 );
}
int stringID = TexDataStringTable_AddOrFindString( pMacroTextureName );
g_FaceMacroTextureInfos[iFace].m_MacroTextureNameID = (unsigned short)stringID;
}
else
{
g_FaceMacroTextureInfos[iFace].m_MacroTextureNameID = 0xFFFF;
}
}
}
bool AddModelNameFromSource( CUtlDict< ModelFile, int >& models, char const *filename, char const *modelname, int offset )
{
int idx = models.Find( modelname );
if ( idx != models.InvalidIndex() )
{
char shortname[ MAX_PATH ];
char shortname2[ MAX_PATH ];
strcpy( shortname, &filename[ offset ] );
strcpy( shortname2, &models[ idx ].qcfile[ offset ] );
vprint( 0, "multiple .qc's build %s\n %s\n %s\n",
modelname,
shortname,
shortname2 );
return false;
}
ModelFile mf;
strcpy( mf.qcfile, filename );
_strlwr( mf.qcfile );
mf.version = 0;
models.Insert( modelname, mf );
return true;
}
C_BaseEntity *CClassMap::CreateEntity( const char *mapname )
{
int c = m_ClassDict.Count();
int i;
for ( i = 0; i < c; i++ )
{
classentry_t *lookup = &m_ClassDict[ i ];
if ( !lookup )
continue;
if ( Q_stricmp( lookup->GetMapName(), mapname ) )
continue;
if ( !lookup->factory )
{
#if defined( _DEBUG )
Msg( "No factory for %s/%s\n", lookup->GetMapName(), m_ClassDict.GetElementName( i ) );
#endif
continue;
}
return ( *lookup->factory )();
}
return NULL;
}
//-----------------------------------------------------------------------------
// Reloads all textures
//-----------------------------------------------------------------------------
void CTextureManager::ReloadTextures()
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// Put the texture back onto the board
m_TextureList[i]->Download();
}
}
// called from cl_parse.cpp
// find the server side decal id given it's name.
// used for save/restore
int Draw_DecalIndexFromName( char *name )
{
int lookup = g_DecalDictionary.Find( name );
if ( lookup == g_DecalDictionary.InvalidIndex() )
return 0;
return g_DecalDictionary[ lookup ].index;
}
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();
}
CMacroTextureData* FindMacroTexture( const char *pFilename )
{
int index = g_MacroTextureLookup.Find( pFilename );
if ( g_MacroTextureLookup.IsValidIndex( index ) )
return g_MacroTextureLookup[index];
else
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Find but don't add mapping
//-----------------------------------------------------------------------------
PanelAnimationMap *CPanelAnimationDictionary::FindPanelAnimationMap( char const *className )
{
int lookup = m_AnimationMaps.Find( StripNamespace( className ) );
if ( lookup != m_AnimationMaps.InvalidIndex() )
{
return m_AnimationMaps[ lookup ].map;
}
return NULL;
}
void ClearKeyValuesCache()
{
MEM_ALLOC_CREDIT();
for ( int i=g_KeyValuesCache.First(); i != g_KeyValuesCache.InvalidIndex(); i=g_KeyValuesCache.Next( i ) )
{
g_KeyValuesCache[i]->deleteThis();
}
g_KeyValuesCache.Purge();
}
//-----------------------------------------------------------------------------
// 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();
}
//-----------------------------------------------------------------------------
// Releases all textures (cause we've lost video memory)
//-----------------------------------------------------------------------------
void CTextureManager::ReleaseTextures( void )
{
g_pShaderAPI->SetFullScreenTextureHandle( INVALID_SHADERAPI_TEXTURE_HANDLE );
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// Release the texture...
m_TextureList[i]->Release();
}
}
void CTextureManager::ReloadFilesInList( IFileList *pFilesToReload )
{
if ( !IsPC() )
return;
for ( int i=m_TextureList.First(); i != m_TextureList.InvalidIndex(); i=m_TextureList.Next( i ) )
{
ITextureInternal *pTex = m_TextureList[i];
pTex->ReloadFilesInList( pFilesToReload );
}
}
int CMapEntities::FindNamedEntity( char const *name )
{
char lowername[ 128 ];
strcpy( lowername, name );
_strlwr( lowername );
int index = m_Entities.Find( lowername );
if ( index == m_Entities.InvalidIndex() )
return -1;
return index;
}
const char *CClassMap::Lookup( const char *classname )
{
unsigned short index;
static classentry_t lookup;
index = m_ClassDict.Find( classname );
if ( index == m_ClassDict.InvalidIndex() )
return NULL;
lookup = m_ClassDict.Element( index );
return lookup.GetMapName();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : gamematerial -
// Output : char const
//-----------------------------------------------------------------------------
char const *CDecalEmitterSystem::ImpactDecalForGameMaterial( int gamematerial )
{
char gm[ 2 ];
gm[0] = (char)gamematerial;
gm[1] = 0;
int idx = m_GameMaterialTranslation.Find( gm );
if ( idx == m_GameMaterialTranslation.InvalidIndex() )
return NULL;
return m_Decals.GetElementName( m_GameMaterialTranslation.Element(idx) );
}
// Message handler for PyNetworkCls
void __MsgFunc_PyNetworkCls( bf_read &msg )
{
char clientClass[PYNETCLS_BUFSIZE];
char networkName[PYNETCLS_BUFSIZE];
int iType = msg.ReadByte();
msg.ReadString(clientClass, PYNETCLS_BUFSIZE);
msg.ReadString(networkName, PYNETCLS_BUFSIZE);
DbgStrPyMsg( "__MsgFunc_PyNetworkCls: Registering Python network class message %d %s %s\n", iType, clientClass, networkName );
// Get module path
const char *pch = Q_strrchr( networkName, '.' );
if( !pch )
{
Warning( "Invalid python class name %s\n", networkName );
return;
}
int n = pch - networkName + 1;
char modulePath[PYNETCLS_BUFSIZE];
Q_strncpy( modulePath, networkName, n );
// Make sure the client class is imported
SrcPySystem()->Import( modulePath );
// Read which client class we are modifying
PyClientClassBase *p = FindPyClientClass( clientClass );
if( !p )
{
Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %s\n", clientClass );
return;
}
// Set type
p->SetType( iType );
SetupClientClassRecv( p, iType );
// Read network class name
Q_strncpy( p->m_strPyNetworkedClassName, networkName, PYNETCLS_BUFSIZE );
// Attach if a network class exists
unsigned short lookup = m_NetworkClassDatabase.Find( networkName );
if ( lookup != m_NetworkClassDatabase.InvalidIndex() )
{
m_NetworkClassDatabase.Element(lookup)->AttachClientClass( p );
}
else
{
Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %s\n", networkName );
}
}
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
}
