//----------------------------------------------------------------------------- // Purpose: Static method // Input : *event - // soundlist - //----------------------------------------------------------------------------- void CSceneCache::PrecacheSceneEvent( CChoreoEvent *event, CUtlVector< unsigned short >& soundlist ) { if ( !event || event->GetType() != CChoreoEvent::SPEAK ) return; int idx = soundemitterbase->GetSoundIndex( event->GetParameters() ); if ( idx != -1 ) { MEM_ALLOC_CREDIT(); Assert( idx <= 65535 ); soundlist.AddToTail( (unsigned short)idx ); } if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER ) { char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ]; if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) ) { int idx = soundemitterbase->GetSoundIndex( tok ); if ( idx != -1 && soundlist.Find( idx ) == soundlist.InvalidIndex() ) { MEM_ALLOC_CREDIT(); Assert( idx <= 65535 ); soundlist.AddToTail( (unsigned short)idx ); } } } }
//----------------------------------------------------------------------------- // Level init, shutdown //----------------------------------------------------------------------------- void CClientLeafSystem::LevelInitPreEntity() { MEM_ALLOC_CREDIT(); m_Renderables.EnsureCapacity( 1024 ); m_RenderablesInLeaf.EnsureCapacity( 1024 ); m_ShadowsInLeaf.EnsureCapacity( 256 ); m_ShadowsOnRenderable.EnsureCapacity( 256 ); m_DirtyRenderables.EnsureCapacity( 256 ); // Add all the leaves we'll need int leafCount = engine->LevelLeafCount(); m_Leaf.EnsureCapacity( leafCount ); ClientLeaf_t newLeaf; newLeaf.m_FirstElement = m_RenderablesInLeaf.InvalidIndex(); newLeaf.m_FirstShadow = m_ShadowsInLeaf.InvalidIndex(); newLeaf.m_FirstDetailProp = 0; newLeaf.m_DetailPropCount = 0; newLeaf.m_DetailPropRenderFrame = -1; while ( --leafCount >= 0 ) { m_Leaf.AddToTail( newLeaf ); } }
void virtualmodel_t::AppendModels( int group, const studiohdr_t *pStudioHdr ) { AUTO_LOCK_( CThreadTerminalMutex<CThreadFastMutex>, m_Lock ); // build a search table if necesary CModelLookupContext ctx(group, pStudioHdr); AppendSequences( group, pStudioHdr ); AppendAnimations( group, pStudioHdr ); AppendBonemap( group, pStudioHdr ); AppendAttachments( group, pStudioHdr ); AppendPoseParameters( group, pStudioHdr ); AppendNodes( group, pStudioHdr ); AppendIKLocks( group, pStudioHdr ); struct HandleAndHeader_t { void *handle; const studiohdr_t *pHdr; }; HandleAndHeader_t list[64]; // determine quantity of valid include models in one pass only // temporarily cache results off, otherwise FindModel() causes ref counting problems int j; int nValidIncludes = 0; for (j = 0; j < pStudioHdr->numincludemodels; j++) { // find model (increases ref count) void *tmp = NULL; const studiohdr_t *pTmpHdr = pStudioHdr->FindModel( &tmp, pStudioHdr->pModelGroup( j )->pszName() ); if ( pTmpHdr ) { if ( nValidIncludes >= ARRAYSIZE( list ) ) { // would cause stack overflow Assert( 0 ); break; } list[nValidIncludes].handle = tmp; list[nValidIncludes].pHdr = pTmpHdr; nValidIncludes++; } } if ( nValidIncludes ) { m_group.EnsureCapacity( m_group.Count() + nValidIncludes ); for (j = 0; j < nValidIncludes; j++) { MEM_ALLOC_CREDIT(); int group = m_group.AddToTail(); m_group[group].cache = list[j].handle; AppendModels( group, list[j].pHdr ); } } UpdateAutoplaySequences( pStudioHdr ); }
void EntityChanged( CBaseEntity *pEntity ) { // might change after deletion, don't put back into the list if ( pEntity->IsMarkedForDeletion() ) return; const CBaseHandle &eh = pEntity->GetRefEHandle(); if ( !eh.IsValid() ) return; int index = eh.GetEntryIndex(); // UNDONE: Maintain separate lists for "no think/no sim" and just "no sim" // UNDONE: Keep "no sim" list sorted by thinktime // UNDONE: Add query for "no sim" list that includes a time and just get ents that will think by that time if ( pEntity->IsEFlagSet( EFL_NO_THINK_FUNCTION ) && pEntity->IsEFlagSet( EFL_NO_GAME_PHYSICS_SIMULATION ) ) { Assert( !pEntity->IsPlayer() ); RemoveEntinfoIndex( index ); } else { // already in the list? (had think or sim last time, now has both - or had both last time, now just one) if ( m_entinfoIndex[index] == 0xFFFF ) { MEM_ALLOC_CREDIT(); m_entinfoIndex[index] = m_simThinkList.AddToTail( (unsigned short)index ); } } }
void Draw_DecalSetName( int decal, char *name ) { while ( decal >= g_DecalLookup.Count() ) { MEM_ALLOC_CREDIT(); int idx = g_DecalLookup.AddToTail(); g_DecalLookup[idx] = g_DecalDictionary.InvalidIndex(); } FileNameHandle_t fnHandle = g_pFileSystem->FindOrAddFileName( name ); int lookup = g_DecalDictionary.Find( fnHandle ); if ( lookup == g_DecalDictionary.InvalidIndex() ) { DecalEntry entry; #ifdef _DEBUG int len = strlen(name) + 1; entry.m_pDebugName = new char[len]; memcpy( entry.m_pDebugName, name, len ); #endif entry.material = GL_LoadMaterial( name, TEXTURE_GROUP_DECAL ); entry.index = decal; lookup = g_DecalDictionary.Insert( fnHandle, entry ); } else { g_DecalDictionary[lookup].index = decal; } g_DecalLookup[decal] = lookup; }
void CGameUI2::Initialize(CreateInterfaceFn appFactory) { MEM_ALLOC_CREDIT(); ConnectTier1Libraries(&appFactory, 1); ConnectTier2Libraries(&appFactory, 1); ConVar_Register(FCVAR_CLIENTDLL); ConnectTier3Libraries(&appFactory, 1); engine = static_cast<IVEngineClient*>(appFactory(VENGINE_CLIENT_INTERFACE_VERSION, nullptr)); enginesound = static_cast<IEngineSound*>(appFactory(IENGINESOUND_CLIENT_INTERFACE_VERSION, nullptr)); enginevgui = static_cast<IEngineVGui*>(appFactory(VENGINE_VGUI_VERSION, nullptr)); soundemitterbase = static_cast<ISoundEmitterSystemBase*>(appFactory(SOUNDEMITTERSYSTEM_INTERFACE_VERSION, nullptr)); render = static_cast<IVRenderView*>(appFactory(VENGINE_RENDERVIEW_INTERFACE_VERSION, nullptr)); CreateInterfaceFn gameUIFactory = g_GameUI.GetFactory(); if (gameUIFactory) gameui = static_cast<IGameUI*>(gameUIFactory(GAMEUI_INTERFACE_VERSION, nullptr)); if (!enginesound || !enginevgui || !engine || !soundemitterbase || !render || !gameui) Error("CGameUI2::Initialize() failed to get necessary interfaces.\n"); if (!CommandLine()->FindParm("-shaderedit")) { GetBasePanel()->Create(); if (GetBasePanel()) gameui->SetMainMenuOverride(GetBasePanel()->GetMainMenu()->GetVPanel()); } }
void PhysicsLevelInit( void ) { physenv = physics->CreateEnvironment(); assert( physenv ); #ifdef PORTAL physenv_main = physenv; #endif { MEM_ALLOC_CREDIT(); g_EntityCollisionHash = physics->CreateObjectPairHash(); } // TODO: need to get the right factory function here //physenv->SetDebugOverlay( appSystemFactory ); physenv->SetGravity( Vector(0, 0, -sv_gravity.GetFloat() ) ); physenv->SetAlternateGravity( Vector(0, 0, -cl_ragdoll_gravity.GetFloat() ) ); // NOTE: Always run client physics at a rate >= 45Hz - helps keep ragdolls stable const float defaultPhysicsTick = 1.0f / 60.0f; // 60Hz to stay in sync with x360 framerate of 30Hz physenv->SetSimulationTimestep( defaultPhysicsTick ); physenv->SetCollisionEventHandler( &g_Collisions ); physenv->SetCollisionSolver( &g_Collisions ); C_World *pWorld = GetClientWorldEntity(); g_PhysWorldObject = PhysCreateWorld_Shared( pWorld, modelinfo->GetVCollide(1), g_PhysDefaultObjectParams ); staticpropmgr->CreateVPhysicsRepresentations( physenv, &g_SolidSetup, pWorld ); }
void PhysicsLevelInit( void ) { physenv = physics->CreateEnvironment(); assert( physenv ); #ifdef PORTAL physenv_main = physenv; #endif { MEM_ALLOC_CREDIT(); g_EntityCollisionHash = physics->CreateObjectPairHash(); } // TODO: need to get the right factory function here //physenv->SetDebugOverlay( appSystemFactory ); physenv->SetGravity( Vector(0, 0, -sv_gravity.GetFloat() ) ); // 15 ms per tick // NOTE: Always run client physics at this rate - helps keep ragdolls stable physenv->SetSimulationTimestep( IsXbox() ? DEFAULT_XBOX_CLIENT_VPHYSICS_TICK : DEFAULT_TICK_INTERVAL ); physenv->SetCollisionEventHandler( &g_Collisions ); physenv->SetCollisionSolver( &g_Collisions ); g_PhysWorldObject = PhysCreateWorld_Shared( GetClientWorldEntity(), modelinfo->GetVCollide(1), g_PhysDefaultObjectParams ); staticpropmgr->CreateVPhysicsRepresentations( physenv, &g_SolidSetup, NULL ); }
void virtualmodel_t::AppendAnimations( int group, const studiohdr_t *pStudioHdr ) { AUTO_LOCK_( CThreadTerminalMutex<CThreadFastMutex>, m_Lock ); int numCheck = m_anim.Count(); CUtlVector< virtualgeneric_t > anim; anim = m_anim; MEM_ALLOC_CREDIT(); int j, k; m_group[ group ].masterAnim.SetCount( pStudioHdr->numlocalanim ); for (j = 0; j < pStudioHdr->numlocalanim; j++) { char *s1 = pStudioHdr->pLocalAnimdesc( j )->pszName(); if ( HasLookupTable() ) { k = numCheck; short index = GetAnimTable()->Find( s1 ); if ( index != GetAnimTable()->InvalidIndex() ) { k = GetAnimTable()->Element(index); } } else { for (k = 0; k < numCheck; k++) { char *s2 = m_group[ anim[k].group ].GetStudioHdr()->pLocalAnimdesc( anim[k].index )->pszName(); if (stricmp( s1, s2 ) == 0) { break; } } } // no duplication if (k == numCheck) { virtualgeneric_t tmp; tmp.group = group; tmp.index = j; k = anim.AddToTail( tmp ); } m_group[ group ].masterAnim[ j ] = k; } if ( HasLookupTable() ) { for ( j = numCheck; j < anim.Count(); j++ ) { const char *s1 = m_group[ anim[j].group ].GetStudioHdr()->pLocalAnimdesc( anim[j].index )->pszName(); GetAnimTable()->Insert( s1, j ); } } m_anim = anim; }
void CBaseGameStats_Driver::PossibleMapChange( void ) { #ifdef GAME_DLL //detect and copy map changes if ( Q_stricmp( m_PrevMapName.String(), STRING( gpGlobals->mapname ) ) ) { MEM_ALLOC_CREDIT(); CUtlString PrevMapBackup = m_PrevMapName; m_PrevMapName = STRING( gpGlobals->mapname ); gamestats->Event_MapChange( PrevMapBackup.String(), STRING( gpGlobals->mapname ) ); if ( gamestats->UseOldFormat() ) { if( gamestats->AutoSave_OnMapChange() ) gamestats->SaveToFileNOW(); if( gamestats->AutoUpload_OnMapChange() ) gamestats->UploadStatsFileNOW(); } } #endif }
static void SortSpawnListByHierarchy( int nEntities, HierarchicalSpawn_t *pSpawnList ) { MEM_ALLOC_CREDIT(); g_pClassnameSpawnPriority = new CStringRegistry; // this will cause the entities to be spawned in the indicated order // Highest string ID spawns first. String ID is spawn priority. // by default, anything not in this list has priority -1 g_pClassnameSpawnPriority->AddString( "func_wall", 10 ); g_pClassnameSpawnPriority->AddString( "scripted_sequence", 9 ); g_pClassnameSpawnPriority->AddString( "phys_hinge", 8 ); g_pClassnameSpawnPriority->AddString( "phys_ballsocket", 8 ); g_pClassnameSpawnPriority->AddString( "phys_slideconstraint", 8 ); g_pClassnameSpawnPriority->AddString( "phys_constraint", 8 ); g_pClassnameSpawnPriority->AddString( "phys_pulleyconstraint", 8 ); g_pClassnameSpawnPriority->AddString( "phys_lengthconstraint", 8 ); g_pClassnameSpawnPriority->AddString( "phys_ragdollconstraint", 8 ); g_pClassnameSpawnPriority->AddString( "info_mass_center", 8 ); // spawn these before physbox/prop_physics g_pClassnameSpawnPriority->AddString( "trigger_vphysics_motion", 8 ); // spawn these before physbox/prop_physics g_pClassnameSpawnPriority->AddString( "prop_physics", 7 ); g_pClassnameSpawnPriority->AddString( "prop_ragdoll", 7 ); // Sort the entities (other than the world) by hierarchy depth, in order to spawn them in // that order. This insures that each entity's parent spawns before it does so that // it can properly set up anything that relies on hierarchy. #ifdef _WIN32 qsort(&pSpawnList[0], nEntities, sizeof(pSpawnList[0]), (int (__cdecl *)(const void *, const void *))CompareSpawnOrder); #elif POSIX qsort(&pSpawnList[0], nEntities, sizeof(pSpawnList[0]), (int (*)(const void *, const void *))CompareSpawnOrder); #endif delete g_pClassnameSpawnPriority; g_pClassnameSpawnPriority = NULL; }
//----------------------------------------------------------------------------- // Purpose: Add an activity to the activity string registry and increment // the acitivty counter //----------------------------------------------------------------------------- void CAI_BaseNPC::AddActivityToSR(const char *actName, int actID) { Assert( m_pActivitySR ); if ( !m_pActivitySR ) return; // technically order isn't dependent, but it's too damn easy to forget to add new ACT_'s to all three lists. // NOTE: This assertion generally means that the activity enums are out of order or that new enums were not added to all // relevant tables. Make sure that you have included all new enums in: // game_shared/ai_activity.h // game_shared/activitylist.cpp // dlls/ai_activity.cpp MEM_ALLOC_CREDIT(); static int lastActID = -2; Assert( actID >= LAST_SHARED_ACTIVITY || actID == lastActID + 1 || actID == ACT_INVALID ); lastActID = actID; if ( m_pActivitySR->GetStringID( actName ) != -1 ) { printf( "Duplicate\n" ); } m_pActivitySR->AddString(actName, actID); m_iNumActivities++; }
void CUtlBinaryBlock::SetLength( int nLength ) { MEM_ALLOC_CREDIT(); Assert( !m_Memory.IsReadOnly() ); m_nActualLength = nLength; if ( nLength > m_Memory.NumAllocated() ) { int nOverFlow = nLength - m_Memory.NumAllocated(); m_Memory.Grow( nOverFlow ); // If the reallocation failed, clamp length if ( nLength > m_Memory.NumAllocated() ) { m_nActualLength = m_Memory.NumAllocated(); } } #ifdef _DEBUG if ( m_Memory.NumAllocated() > m_nActualLength ) { memset( ( ( char * )m_Memory.Base() ) + m_nActualLength, 0xEB, m_Memory.NumAllocated() - m_nActualLength ); } #endif }
//----------------------------------------------------------------------------- // Base class, containing simple memory management //----------------------------------------------------------------------------- CUtlBinaryBlock::CUtlBinaryBlock( int growSize, int initSize ) { MEM_ALLOC_CREDIT(); m_Memory.Init( growSize, initSize ); m_nActualLength = 0; }
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: //----------------------------------------------------------------------------- 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 CGameUI::SendConnectedToGameMessage() { MEM_ALLOC_CREDIT(); KeyValues *kv = new KeyValues( "ConnectedToGame" ); kv->SetInt( "ip", m_iGameIP ); kv->SetInt( "connectionport", m_iGameConnectionPort ); kv->SetInt( "queryport", m_iGameQueryPort ); g_VModuleLoader.PostMessageToAllModules( kv ); }
//----------------------------------------------------------------------------- // Purpose: Static method // Input : sounds - // *soundname - //----------------------------------------------------------------------------- void CModelSoundsCache::FindOrAddScriptSound( CUtlVector< unsigned short >& sounds, char const *soundname ) { int soundindex = soundemitterbase->GetSoundIndex( soundname ); if ( soundindex != -1 ) { // Only add it once per model... if ( sounds.Find( soundindex ) == sounds.InvalidIndex() ) { MEM_ALLOC_CREDIT(); sounds.AddToTail( soundindex ); } } }
void virtualmodel_t::AppendPoseParameters( int group, const studiohdr_t *pStudioHdr ) { AUTO_LOCK_( CThreadTerminalMutex<CThreadFastMutex>, m_Lock ); int numCheck = m_pose.Count(); CUtlVector< virtualgeneric_t > pose; pose = m_pose; MEM_ALLOC_CREDIT(); int j, k; m_group[ group ].masterPose.SetCount( pStudioHdr->numlocalposeparameters ); for (j = 0; j < pStudioHdr->numlocalposeparameters; j++) { char *s1 = pStudioHdr->pLocalPoseParameter( j )->pszName(); for (k = 0; k < numCheck; k++) { char *s2 = m_group[ pose[k].group ].GetStudioHdr()->pLocalPoseParameter( pose[k].index )->pszName(); if (stricmp( s1, s2 ) == 0) { break; } } if (k == numCheck) { // no duplication virtualgeneric_t tmp; tmp.group = group; tmp.index = j; k = pose.AddToTail( tmp ); } else { // duplicate, reset start and end to fit full dynamic range mstudioposeparamdesc_t *pPose1 = pStudioHdr->pLocalPoseParameter( j ); mstudioposeparamdesc_t *pPose2 = m_group[ pose[k].group ].GetStudioHdr()->pLocalPoseParameter( pose[k].index ); float start = min( pPose2->end, min( pPose1->end, min( pPose2->start, pPose1->start ) ) ); float end = max( pPose2->end, max( pPose1->end, max( pPose2->start, pPose1->start ) ) ); pPose2->start = start; pPose2->end = end; } m_group[ group ].masterPose[ j ] = k; } m_pose = pose; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CGameUI::SetProgressLevelName( const char *levelName ) { MEM_ALLOC_CREDIT(); if ( g_hLoadingBackgroundDialog ) { KeyValues *pKV = new KeyValues( "ProgressLevelName" ); pKV->SetString( "levelName", levelName ); vgui::ivgui()->PostMessage( g_hLoadingBackgroundDialog, pKV, NULL ); } if ( g_hLoadingDialog.Get() ) { // TODO: g_hLoadingDialog->SetLevelName( levelName ); } }
//----------------------------------------------------------------------------- // 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]; } }
void CAI_GlobalNamespace::AddSymbol( const char *pszSymbol, int symbolID ) { MEM_ALLOC_CREDIT(); AssertMsg( symbolID != -1, "Invalid symbol id passed to CAI_GlobalNamespace::AddSymbol()" ); if (symbolID == -1 ) return; AssertMsg( AI_IdIsGlobal( symbolID ), ("Local symbol ID passed to CAI_GlobalNamespace::AddSymbol()") ); AssertMsg( !IdToSymbol( symbolID ) , ("Duplicate symbol ID passed to CAI_GlobalNamespace::AddSymbol()") ); AssertMsg( SymbolToId( pszSymbol ) == -1, ("Duplicate symbol passed to CAI_GlobalNamespace::AddSymbol()") ); m_pSymbols->AddString( pszSymbol, symbolID ); if ( m_NextGlobalBase < symbolID + 1 ) m_NextGlobalBase = symbolID + 1; }
CCountedStringPool::CCountedStringPool() { MEM_ALLOC_CREDIT(); m_HashTable.EnsureCount(HASH_TABLE_SIZE); for( int i = 0; i < m_HashTable.Count(); i++ ) { m_HashTable[i] = INVALID_ELEMENT; } m_FreeListStart = INVALID_ELEMENT; m_Elements.AddToTail(); m_Elements[0].pString = NULL; m_Elements[0].nReferenceCount = 0; m_Elements[0].nNextElement = INVALID_ELEMENT; }
//----------------------------------------------------------------------------- // Purpose: // Input : *criteria - // "" - // 1.0f - //----------------------------------------------------------------------------- void AI_CriteriaSet::AppendCriteria( const char *criteria, const char *value /*= ""*/, float weight /*= 1.0f*/ ) { int idx = FindCriterionIndex( criteria ); if ( idx == -1 ) { CritEntry_t entry; entry.criterianame = criteria; MEM_ALLOC_CREDIT(); idx = m_Lookup.Insert( entry ); } CritEntry_t *entry = &m_Lookup[ idx ]; entry->SetValue( value ); entry->weight = weight; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void ParseParticleEffects( bool bLoadSheets, bool bPrecache ) { MEM_ALLOC_CREDIT(); g_pParticleSystemMgr->ShouldLoadSheets( bLoadSheets ); CUtlVector<CUtlString> files; GetParticleManifest( files ); int nCount = files.Count(); for ( int i = 0; i < nCount; ++i ) { g_pParticleSystemMgr->ReadParticleConfigFile( files[i], bPrecache, false ); } g_pParticleSystemMgr->DecommitTempMemory(); }
// Assumed to be set up by calling code bool AsyncCaption_t::LoadFromFile( const char *pRelativePath ) { char pRelativePathFixed[MAX_PATH]; Q_strncpy( pRelativePathFixed, pRelativePath, sizeof(pRelativePathFixed) ); Q_FixSlashes( pRelativePathFixed ); Q_strlower( pRelativePathFixed ); pRelativePath = pRelativePathFixed; if ( Q_IsAbsolutePath( pRelativePath ) ) { Warning( "AsyncCaption_t::LoadFromFile: Fullpath encountered! %s\n", pRelativePath ); } FileHandle_t fh = g_pFullFileSystem->Open( pRelativePath, "rb", "GAME" ); if ( FILESYSTEM_INVALID_HANDLE == fh ) return false; MEM_ALLOC_CREDIT(); CUtlBuffer dirbuffer; // Read the header g_pFullFileSystem->Read( &m_Header, sizeof( m_Header ), fh ); if ( m_Header.magic != COMPILED_CAPTION_FILEID ) Error( "Invalid file id for %s\n", pRelativePath ); if ( m_Header.version != COMPILED_CAPTION_VERSION ) Error( "Invalid file version for %s\n", pRelativePath ); if ( m_Header.directorysize < 0 || m_Header.directorysize > 64 * 1024 ) Error( "Invalid directory size %d for %s\n", m_Header.directorysize, pRelativePath ); //if ( m_Header.blocksize != MAX_BLOCK_SIZE ) // Error( "Invalid block size %d, expecting %d for %s\n", m_Header.blocksize, MAX_BLOCK_SIZE, pchFullPath ); int directoryBytes = m_Header.directorysize * sizeof( CaptionLookup_t ); m_CaptionDirectory.EnsureCapacity( m_Header.directorysize ); dirbuffer.EnsureCapacity( directoryBytes ); g_pFullFileSystem->Read( dirbuffer.Base(), directoryBytes, fh ); g_pFullFileSystem->Close( fh ); m_CaptionDirectory.CopyArray( (const CaptionLookup_t *)dirbuffer.PeekGet(), m_Header.directorysize ); m_CaptionDirectory.RedoSort( true ); m_DataBaseFile = pRelativePath; return true; }
void EntityChanged( CBaseEntity *pEntity ) { // might change after deletion, don't put back into the list if ( pEntity->IsMarkedForDeletion() ) return; const CBaseHandle &eh = pEntity->GetRefEHandle(); if ( !eh.IsValid() ) return; int index = eh.GetEntryIndex(); if ( pEntity->IsEFlagSet( EFL_NO_THINK_FUNCTION ) && pEntity->IsEFlagSet( EFL_NO_GAME_PHYSICS_SIMULATION ) ) { RemoveEntinfoIndex( index ); } else { // already in the list? (had think or sim last time, now has both - or had both last time, now just one) if ( m_entinfoIndex[index] == 0xFFFF ) { MEM_ALLOC_CREDIT(); m_entinfoIndex[index] = m_simThinkList.AddToTail(); m_simThinkList[m_entinfoIndex[index]].entEntry = (unsigned short)index; m_simThinkList[m_entinfoIndex[index]].nextThinkTick = 0; if ( pEntity->IsEFlagSet(EFL_NO_GAME_PHYSICS_SIMULATION) ) { m_simThinkList[m_entinfoIndex[index]].nextThinkTick = pEntity->GetFirstThinkTick(); Assert(m_simThinkList[m_entinfoIndex[index]].nextThinkTick>=0); } } else { // updating existing entry - if no sim, reset think time if ( pEntity->IsEFlagSet(EFL_NO_GAME_PHYSICS_SIMULATION) ) { m_simThinkList[m_entinfoIndex[index]].nextThinkTick = pEntity->GetFirstThinkTick(); Assert(m_simThinkList[m_entinfoIndex[index]].nextThinkTick>=0); } else { m_simThinkList[m_entinfoIndex[index]].nextThinkTick = 0; } } } }
//----------------------------------------------------------------------------- // Purpose: loads per-map manifest! //----------------------------------------------------------------------------- void ParseParticleEffectsMap( const char *pMapName, bool bLoadSheets ) { MEM_ALLOC_CREDIT(); g_pParticleSystemMgr->ShouldLoadSheets( bLoadSheets ); CUtlVector<CUtlString> files; const char *mapManifestFilename = NULL; if ( pMapName && *pMapName ) { #ifdef CLIENT_DLL #define UTIL_VarArgs VarArgs //Tony; goddamnit. #endif mapManifestFilename = UTIL_VarArgs( "particles/particles_%s.txt", pMapName ); } // Open the manifest file, and read the particles specified inside it KeyValues *manifest = new KeyValues( mapManifestFilename ); if ( manifest->LoadFromFile( filesystem, mapManifestFilename, "GAME" ) ) { for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() ) { if ( !Q_stricmp( sub->GetName(), "file" ) ) { files.AddToTail( sub->GetString() ); continue; } Warning( "CParticleMgr::LevelInit: Manifest '%s' with bogus file type '%s', expecting 'file'\n", mapManifestFilename, sub->GetName() ); } } else //Tony; don't print a warning, and don't proceed any further if the file doesn't exist! return; int nCount = files.Count(); for ( int i = 0; i < nCount; ++i ) { g_pParticleSystemMgr->ReadParticleConfigFile( files[i], true, true ); } g_pParticleSystemMgr->DecommitTempMemory(); }
// add a new event to the database eventlist_t *EventList_AddEventEntry( const char *pName, int iEventIndex, bool isPrivate, int iType ) { MEM_ALLOC_CREDIT(); int index = g_EventList.AddToTail(); eventlist_t *pList = &g_EventList[index]; pList->eventIndex = iEventIndex; pList->stringKey = g_EventStrings.AddString( pName, index ); pList->isPrivate = isPrivate; pList->iType = iType; // UNDONE: This implies that ALL shared activities are added before ANY custom activities // UNDONE: Segment these instead? It's a 32-bit int, how many activities do we need? if ( iEventIndex > g_HighestEvent ) { g_HighestEvent = iEventIndex; } return pList; }