//----------------------------------------------------------------------------- // 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; }
PyEntityFactory* CClassMap::PyGetFactory( const char *classname ) { int index = m_ClassDict.Find( classname ); if( index == m_ClassDict.InvalidIndex() ) return NULL; return m_ClassDict[index].pyfactory; }
//----------------------------------------------------------------------------- // 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; }
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); }
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; }
//----------------------------------------------------------------------------- // 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; }
//----------------------------------------------------------------------------- // 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 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 }
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; }
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; } } }
// 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; }
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; }
ITextureInternal *CTextureManager::FindTexture( const char *pTextureName ) { if ( !pTextureName || pTextureName[0] == 0 ) return NULL; char szCleanName[MAX_PATH]; NormalizeTextureName( pTextureName, szCleanName, sizeof( szCleanName ) ); int i = m_TextureList.Find( szCleanName ); if ( i != m_TextureList.InvalidIndex() ) { return m_TextureList[i]; } i = m_TextureAliases.Find( szCleanName ); if ( i != m_TextureAliases.InvalidIndex() ) { return FindTexture( m_TextureAliases[i] ); } // Special handling: lightmaps if ( char const *szLightMapNum = StringAfterPrefix( szCleanName, "[lightmap" ) ) { int iLightMapNum = atoi( szLightMapNum ); extern CMaterialSystem g_MaterialSystem; CMatLightmaps *plm = g_MaterialSystem.GetLightmaps(); if ( iLightMapNum >= 0 && iLightMapNum < plm->GetNumLightmapPages() ) { ShaderAPITextureHandle_t hTex = plm->GetLightmapPageTextureHandle( iLightMapNum ); if ( hTex != INVALID_SHADERAPI_TEXTURE_HANDLE ) { // Establish the lookup linking in the dictionary ITextureInternal *pTxInt = ITextureInternal::CreateReferenceTextureFromHandle( pTextureName, TEXTURE_GROUP_LIGHTMAP, hTex ); m_TextureList.Insert( pTextureName, pTxInt ); return pTxInt; } } } return NULL; }
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) ); }
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; }
// 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 CTextureManager::RemoveTextureAlias( const char *pAlias ) { if ( pAlias == NULL ) return; char szCleanName[MAX_PATH]; int index = m_TextureAliases.Find( NormalizeTextureName( pAlias, szCleanName, sizeof( szCleanName ) ) ); if ( index == m_TextureAliases.InvalidIndex() ) return; //not found delete []m_TextureAliases[index]; m_TextureAliases.RemoveAt( index ); }
void CorrelateWavsAndVCDs( CUtlVector< CUtlSymbol >& vcdfiles, CUtlVector< CUtlSymbol >& wavfiles ) { CUtlDict< VCDList, int > database; int i; int c = vcdfiles.Count(); for ( i = 0; i < c; i++ ) { CUtlSymbol& vcdname = vcdfiles[ i ]; // Load the .vcd and update the database ProcessVCD( database, vcdname ); } if ( vcdonly ) return; vprint( 0, "Found %i wav files in %i vcds\n", database.Count(), vcdfiles.Count() ); // Now look for any wavfiles that weren't in the database int ecount = 0; c = wavfiles.Count(); for ( i = 0; i < c; i++ ) { CUtlSymbol& wavename = wavfiles[ i ]; int idx = database.Find( g_Analysis.symbols.String( wavename ) ); if ( idx != database.InvalidIndex() ) { VCDList *listentry = &database[ idx ]; int vcdcount = listentry->vcds.Count(); if ( vcdcount >= 2 && verbose ) { vprint( 0, " wave '%s' used by multiple .vcds:\n", g_Analysis.symbols.String( wavename ) ); int j; for ( j = 0; j < vcdcount; j++ ) { vprint( 1, "%i -- '%s'\n", j+1, g_Analysis.symbols.String( listentry->vcds[ j ] ) ); } } continue; } vprint( 0, "%i -- '%s' not referenced by .vcd\n", ++ecount, g_Analysis.symbols.String( wavename ) ); } vprint( 0, "\nSummary: found %i/%i (%.2f percent) .wav errors\n", ecount, c, 100.0 * ecount / max( c, 1 ) ); }
//----------------------------------------------------------------------------- // Purpose: // Input : *name - // Output : FileItemInfo_t //----------------------------------------------------------------------------- static ITEM_FILE_INFO_HANDLE FindItemInfo( const char *name ) { // Complain about duplicately defined metaclass names... unsigned short lookup = m_ItemInfoDatabase.Find( name ); if ( lookup != m_ItemInfoDatabase.InvalidIndex() ) { return lookup; } FileItemInfo_t *insert = new FileItemInfo_t; // BOXBOX was CreateWeaponInfo(); lookup = m_ItemInfoDatabase.Insert( name, insert ); Assert( lookup != m_ItemInfoDatabase.InvalidIndex() ); return lookup; }
//----------------------------------------------------------------------------- // Purpose: // Input : *name - // Output : FilePlayerClassInfo_t //----------------------------------------------------------------------------- static PLAYERCLASS_FILE_INFO_HANDLE FindPlayerClassInfoSlot( const char *name ) { // Complain about duplicately defined metaclass names... unsigned short lookup = m_PlayerClassInfoDatabase.Find( name ); if ( lookup != m_PlayerClassInfoDatabase.InvalidIndex() ) { return lookup; } FilePlayerClassInfo_t *insert = CreatePlayerClassInfo(); lookup = m_PlayerClassInfoDatabase.Insert( name, insert ); Assert( lookup != m_PlayerClassInfoDatabase.InvalidIndex() ); return lookup; }
//----------------------------------------------------------------------------- // Loads up a file containing metaclass definitions //----------------------------------------------------------------------------- void CPanelMetaClassMgrImp::LoadMetaClassDefinitionFile( const char *pFileName ) { MEM_ALLOC_CREDIT(); // Blat out previous metaclass definitions read in from this file... int i = m_MetaClassKeyValues.Find( pFileName ); if (i != m_MetaClassKeyValues.InvalidIndex() ) { // Blow away the previous keyvalues from that file unsigned short j = m_MetaClassDict.First(); while ( j != m_MetaClassDict.InvalidIndex() ) { unsigned short next = m_MetaClassDict.Next(j); if ( m_MetaClassDict[j].m_KeyValueIndex == i) { m_MetaClassDict.RemoveAt(j); } j = next; } m_MetaClassKeyValues[i]->deleteThis(); m_MetaClassKeyValues.RemoveAt(i); } // Create a new keyvalues entry KeyValues* pKeyValues = new KeyValues(pFileName); int idx = m_MetaClassKeyValues.Insert( pFileName, pKeyValues ); // Read in all metaclass definitions... // Load the file if ( !pKeyValues->LoadFromFile( filesystem, pFileName ) ) { Warning( "Couldn't find metaclass definition file %s\n", pFileName ); pKeyValues->deleteThis(); m_MetaClassKeyValues.RemoveAt(idx); return; } else { // Go ahead and parse the data now if ( !ParseMetaClassList( pFileName, pKeyValues, idx ) ) { Warning( "Detected one or more errors parsing %s\n", pFileName ); } } }
KeyValues* CacheKeyValuesForFile( const char *pFilename ) { MEM_ALLOC_CREDIT(); int i = g_KeyValuesCache.Find( pFilename ); if ( i == g_KeyValuesCache.InvalidIndex() ) { KeyValues *rDat = new KeyValues( pFilename ); rDat->LoadFromFile( filesystem, pFilename, NULL ); g_KeyValuesCache.Insert( pFilename, rDat ); return rDat; } else { return g_KeyValuesCache[i]; } }
// Message handler for PyNetworkCls void __MsgFunc_PyNetworkCls( bf_read &msg ) { int iClassID; char networkName[PYNETCLS_BUFSIZE]; iClassID = msg.ReadWord(); msg.ReadString( networkName, PYNETCLS_BUFSIZE ); DbgStrPyMsg( "__MsgFunc_PyNetworkCls: Registering Python network class message %d %s\n", iClassID, networkName ); // Get module path const char *pch = V_strrchr( networkName, '.' ); if( !pch ) { Warning( "Invalid python class name %s\n", networkName ); return; } int n = pch - networkName + 1; char modulePath[PYNETCLS_BUFSIZE]; V_strncpy( modulePath, networkName, n ); // Make sure the client class is imported SrcPySystem()->Import( modulePath ); // Read which client class we are modifying PyClientClassBase *p = FindPyClientClassByID( iClassID ); if( !p ) { Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %d\n", iClassID ); return; } // Read network class name V_strncpy( p->m_strPyNetworkedClassName, networkName, sizeof( p->m_strPyNetworkedClassName ) ); // 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 ); } }
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 RegisterScriptedTrigger( const char *className ) { if ( EntityFactoryDictionary()->FindFactory( className ) ) { return; } unsigned short lookup = m_TriggerFactoryDatabase.Find( className ); if ( lookup != m_TriggerFactoryDatabase.InvalidIndex() ) { return; } CEntityFactory<CBaseScriptedTrigger> *pFactory = new CEntityFactory<CBaseScriptedTrigger>( className ); lookup = m_TriggerFactoryDatabase.Insert( className, pFactory ); Assert( lookup != m_TriggerFactoryDatabase.InvalidIndex() ); }
/** * 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; }
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 ); }
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 ); }