void CClientLeafSystem::RemoveRenderable( ClientRenderHandle_t handle ) { // This can happen upon level shutdown if (!m_Renderables.IsValidIndex(handle)) return; // Reset the render handle in the entity. IClientRenderable *pRenderable = m_Renderables[handle].m_pRenderable; Assert( handle == pRenderable->RenderHandle() ); pRenderable->RenderHandle() = INVALID_CLIENT_RENDER_HANDLE; // Reemove the renderable from the dirty list if ( m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED ) { // NOTE: This isn't particularly fast (linear search), // but I'm assuming it's an unusual case where we remove // renderables that are changing or that m_DirtyRenderables usually // only has a couple entries int i = m_DirtyRenderables.Find( handle ); Assert( i != m_DirtyRenderables.InvalidIndex() ); m_DirtyRenderables.FastRemove( i ); } if ( IsViewModelRenderGroup( (RenderGroup_t)m_Renderables[handle].m_RenderGroup ) ) { RemoveFromViewModelList( handle ); } RemoveFromTree( handle ); m_Renderables.Remove( handle ); }
//----------------------------------------------------------------------------- // Purpose: Clears all the memory queues and free's their memory //----------------------------------------------------------------------------- void CVGui::ClearMessageQueues() { Assert(!m_InDispatcher); {FOR_EACH_LL( m_MessageQueue, i ) { if (m_MessageQueue[i]._params) { m_MessageQueue[i]._params->deleteThis(); } }} m_MessageQueue.RemoveAll(); // secondary message queue, holds all vgui messages generated by vgui {FOR_EACH_LL( m_SecondaryQueue, i ) { if (m_SecondaryQueue[i]._params) { m_SecondaryQueue[i]._params->deleteThis(); } }} m_SecondaryQueue.RemoveAll(); // timing queue, holds all the messages that have to arrive at a specified time while (m_DelayedMessageQueue.Count() > 0) { if (m_DelayedMessageQueue.ElementAtHead()._params) { m_DelayedMessageQueue.ElementAtHead()._params->deleteThis(); } m_DelayedMessageQueue.RemoveAtHead(); } }
// ----------------------------------------------------------------------------- // // Add/remove decals // ----------------------------------------------------------------------------- // DispDecalHandle_t CDispInfo::NotifyAddDecal( decal_t *pDecal ) { // FIXME: Add decal retirement... // if( m_Decals.Size() < MAX_DISP_DECALS ) // return; // Create a new decal, link it in DispDecalHandle_t h = s_DispDecals.Alloc( true ); // When linking, insert it in sorted order based on material enumeration ID // This will help us when rendering later int last = DISP_DECAL_HANDLE_INVALID; int i = m_FirstDecal; int enumerationId = pDecal->material->GetEnumerationID(); while( i != s_DispDecals.InvalidIndex() ) { int testId = s_DispDecals[i].m_pDecal->material->GetEnumerationID(); if (enumerationId <= testId) break; last = i; i = s_DispDecals.Next(i); } // NOTE: when the list is used in multimode, we can't use LinkBefore( i, INVALID_INDEX ), // since the Head and Tail of the linked list are meaningless... if ( last != DISP_DECAL_HANDLE_INVALID ) s_DispDecals.LinkAfter( last, h ); else { s_DispDecals.LinkBefore( m_FirstDecal, h ); m_FirstDecal = h; } CDispDecal *pDispDecal = &s_DispDecals[h]; pDispDecal->m_pDecal = pDecal; pDispDecal->m_FirstFragment = DISP_DECAL_FRAGMENT_HANDLE_INVALID; pDispDecal->m_nVerts = 0; pDispDecal->m_nTris = 0; // Setup a basis for it. CDecalVert *pOutVerts = NULL; R_SetupDecalClip( pOutVerts, pDispDecal->m_pDecal, MSurf_Plane( m_ParentSurfID ).normal, pDispDecal->m_pDecal->material, pDispDecal->m_TextureSpaceBasis, pDispDecal->m_DecalWorldScale ); // Recurse and precalculate which nodes this thing can touch. SetupDecalNodeIntersect( m_pPowerInfo->m_RootNode, 0, // node bit index into CDispDecal::m_NodeIntersects pDispDecal, 0 ); return h; }
//----------------------------------------------------------------------------- // Purpose: creates the full path for a node //----------------------------------------------------------------------------- void DirectorySelectDialog::GenerateFullPathForNode(int nodeIndex, char *path, int pathBufferSize) { // get all the nodes CUtlLinkedList<int, int> nodes; nodes.AddToTail(nodeIndex); int parentIndex = nodeIndex; while (1) { parentIndex = m_pDirTree->GetItemParent(parentIndex); if (parentIndex == -1) break; nodes.AddToHead(parentIndex); } // walk the nodes, adding to the path path[0] = 0; bool bFirst = true; FOR_EACH_LL( nodes, i ) { KeyValues *kv = m_pDirTree->GetItemData( nodes[i] ); strcat(path, kv->GetString("Text")); if (!bFirst) { strcat(path, "\\"); } bFirst = false; }
//----------------------------------------------------------------------------- // Allocates fragments... //----------------------------------------------------------------------------- CDispShadowFragment* CDispInfo::AllocateShadowDecalFragment( DispShadowHandle_t h ) { DispShadowFragmentHandle_t f = s_DispShadowFragments.Alloc(true); s_DispShadowFragments.LinkBefore( s_DispShadowDecals[h].m_FirstFragment, f ); s_DispShadowDecals[h].m_FirstFragment = f; return &s_DispShadowFragments[f]; }
void CBSPTreeData::Shutdown() { m_Handles.Purge(); m_LeafElements.Purge(); m_HandleLeafList.Purge(); m_Leaf.Purge(); }
void CBSPTreeData::Remove( BSPTreeDataHandle_t handle ) { if (!m_Handles.IsValidIndex(handle)) return; RemoveFromTree( handle ); m_Handles.Free( handle ); }
BSPTreeDataHandle_t CBSPTreeData::NewHandle( int userId ) { BSPTreeDataHandle_t handle = m_Handles.AddToTail(); m_Handles[handle].m_UserId = userId; m_Handles[handle].m_LeafList = m_HandleLeafList.InvalidIndex(); return handle; }
void CGroundLine::DrawAllGroundLines() { VPROF("CGroundLine::DrawAllGroundLines()"); unsigned short i; for( i = s_GroundLines.Head(); i != s_GroundLines.InvalidIndex(); i = s_GroundLines.Next(i) ) { s_GroundLines[i]->Draw(); } }
//----------------------------------------------------------------------------- // Purpose: // Input : *focus - //----------------------------------------------------------------------------- void CInputWin32::PanelDeleted(VPANEL focus) { HInputContext i; for (i = m_Contexts.Head(); i != m_Contexts.InvalidIndex(); i = m_Contexts.Next(i) ) { PanelDeleted( focus, m_Contexts[i] ); } PanelDeleted( focus, m_DefaultInputContext ); }
void CFrameSnapshotManager::LevelChanged() { // Clear all lists... Assert( m_FrameSnapshots.Count() == 0 ); // Release the most recent snapshot... m_PackedEntities.RemoveAll(); memset( m_pPackedData, 0xFF, MAX_EDICTS * sizeof(PackedEntityHandle_t) ); }
//----------------------------------------------------------------------------- // Enumerate elements in a particular leaf //----------------------------------------------------------------------------- int CBSPTreeData::CountElementsInLeaf( int leaf ) { int i; int nCount = 0; for( i = m_Leaf[leaf].m_FirstElement; i != m_LeafElements.InvalidIndex(); i = m_LeafElements.Next(i) ) { ++nCount; } return nCount; }
//----------------------------------------------------------------------------- // Purpose: Destructor //----------------------------------------------------------------------------- CParticleEffect::~CParticleEffect( void ) { #if defined( _DEBUG ) int index = g_ParticleEffects.Find( this ); g_ParticleEffects.Remove( index ); #endif // HACKHACK: Prevent re-entering the destructor, clear m_Flags. // For some reason we'll get a callback into NotifyRemove() after being deleted! // Investigate dangling pointer m_Flags = 0; }
void CVGui::DestroyAllContexts( ) { HContext next; HContext i = m_Contexts.Head(); while (i != m_Contexts.InvalidIndex()) { next = m_Contexts.Next(i); DestroyContext( i ); i = next; } }
void CClientLeafSystem::LevelShutdownPostEntity() { m_ViewModels.Purge(); m_Renderables.Purge(); m_RenderablesInLeaf.Purge(); m_Shadows.Purge(); m_Leaf.Purge(); m_ShadowsInLeaf.Purge(); m_ShadowsOnRenderable.Purge(); m_DirtyRenderables.Purge(); }
void CDispInfo::RemoveShadowDecal( DispShadowHandle_t h ) { // Any fragments we got we don't need ClearShadowDecalFragments(h); // Reset the head of the list if (m_FirstShadowDecal == h) m_FirstShadowDecal = s_DispShadowDecals.Next(h); // Blow away the decal s_DispShadowDecals.Free( h ); }
//----------------------------------------------------------------------------- // Purpose: Adds a message to the queue to be sent to a user //----------------------------------------------------------------------------- void CVGui::PostMessage(VPANEL target, KeyValues *params, VPANEL from, float delay) { // Ignore all messages in re-entrant mode if ( IsReentrant() ) { Assert( 0 ); if (params) { params->deleteThis(); } return; } if (!target) { if (params) { params->deleteThis(); } return; } MessageItem_t messageItem; messageItem._messageTo = (target != (VPANEL)-1) ? g_pIVgui->PanelToHandle(target) : 0xFFFFFFFF; messageItem._params = params; Assert(params->GetName()); messageItem._from = g_pIVgui->PanelToHandle(from); messageItem._arrivalTime = 0; messageItem._messageID = m_iCurrentMessageID++; /* message debug code //if ( stricmp(messageItem._params->GetName(),"CursorMoved") && stricmp(messageItem._params->GetName(),"KeyFocusTicked")) { g_pIVgui->DPrintf2( "posting( %s -- %i )\n", messageItem._params->GetName(), messageItem._messageID ); } */ // add the message to the correct message queue if (delay > 0.0f) { messageItem._arrivalTime = g_pSystem->GetTimeMillis() + (delay * 1000); m_DelayedMessageQueue.Insert(messageItem); } else if (m_InDispatcher) { m_SecondaryQueue.AddToTail(messageItem); } else { m_MessageQueue.AddToTail(messageItem); } }
bool FindJobMemory( int id[4] ) { int iNext; for ( int i=g_JobMemories.Head(); i != g_JobMemories.InvalidIndex(); i=iNext ) { iNext = g_JobMemories.Next( i ); CJobMemory *pJob = &g_JobMemories[i]; if ( memcmp( pJob->m_ID, id, sizeof( pJob->m_ID ) ) == 0 ) return true; } return false; }
void TimeoutJobIDs() { double flCurTime = Plat_FloatTime(); int iNext; for ( int i=g_JobMemories.Head(); i != g_JobMemories.InvalidIndex(); i=iNext ) { iNext = g_JobMemories.Next( i ); if ( (flCurTime - g_JobMemories[i].m_Time) > JOB_MEMORY_DURATION ) g_JobMemories.Remove( i ); } }
//----------------------------------------------------------------------------- // Purpose: Checks for any waiting messages //----------------------------------------------------------------------------- IReceiveMessage *CTrackerNET::GetIncomingData() { // check the receive list if (m_ReceivedMsgs.Count()) { int head = m_ReceivedMsgs.Head(); IReceiveMessage *msg = m_ReceivedMsgs[head].message; m_ReceivedMsgs.Remove(head); return msg; } return NULL; }
//----------------------------------------------------------------------------- // Purpose: Gets any failed sends - returns any packet that could not be delivered //----------------------------------------------------------------------------- IReceiveMessage *CTrackerNET::GetFailedMessage() { if (m_FailedMsgs.Count()) { // pop the failed message from the front of the queue and return it FailedMsg_t &msg = m_FailedMsgs[m_FailedMsgs.Head()]; IReceiveMessage *recvMsg = msg.message; m_FailedMsgs.Remove(m_FailedMsgs.Head()); return recvMsg; } return NULL; }
void CGameGibManager::AddGibToLRU( CBaseAnimating *pEntity ) { int i, next; if ( pEntity == NULL ) return; //Find stale gibs. for ( i = m_LRU.Head(); i < m_LRU.InvalidIndex(); i = next ) { next = m_LRU.Next(i); if ( m_LRU[i].Get() == NULL ) { m_LRU.Remove(i); } } // We're not tracking gibs at the moment if ( m_iCurrentMaxPieces <= 0 ) return; while ( m_LRU.Count() >= m_iCurrentMaxPieces ) { i = m_LRU.Head(); //TODO: Make this fade out instead of pop. UTIL_Remove( m_LRU[i] ); m_LRU.Remove(i); } m_LRU.AddToTail( pEntity ); m_iLastFrame = gpGlobals->framecount; }
static bool EventCollidesWithRows( CUtlLinkedList< CChoreoEvent*, int >& list, CChoreoEvent *event, char *trackName, size_t trackNameLength ) { float st = event->GetStartTime(); float ed = event->GetEndTime(); for ( int i = list.Head(); i != list.InvalidIndex(); i = list.Next( i ) ) { CChoreoEvent *test = list[ i ]; float teststart = test->GetStartTime(); float testend = test->GetEndTime(); // See if spans overlap if ( teststart >= ed ) continue; if ( testend <= st ) continue; // Now see if they deal with the same flex controller int tc = event->GetNumFlexAnimationTracks(); for ( int track = 0; track < tc; ++track ) { CFlexAnimationTrack *t = event->GetFlexAnimationTrack( track ); if ( !t->IsTrackActive() ) { continue; } int sampleCountNormal = t->GetNumSamples( 0 ); int sampleCountBalance = 0; if ( t->IsComboType() ) { sampleCountBalance = t->GetNumSamples( 1 ); } if ( !sampleCountNormal && !sampleCountBalance ) continue; // Otherwise, see if the test track has this as an active track if ( IsFlexTrackBeingUsed( test, t->GetFlexControllerName() ) ) { Q_strncpy( trackName, t->GetFlexControllerName(), trackNameLength ); return true; } } return false; } return false; }
// ----------------------------------------------------------------------------- // // Add/remove shadow decals // ----------------------------------------------------------------------------- // DispShadowHandle_t CDispInfo::AddShadowDecal( ShadowHandle_t shadowHandle ) { // Create a new shadow decal, link it in DispShadowHandle_t h = s_DispShadowDecals.Alloc( true ); s_DispShadowDecals.LinkBefore( m_FirstShadowDecal, h ); m_FirstShadowDecal = h; CDispShadowDecal* pShadowDecal = &s_DispShadowDecals[h]; pShadowDecal->m_nTris = 0; pShadowDecal->m_nVerts = 0; pShadowDecal->m_Shadow = shadowHandle; pShadowDecal->m_FirstFragment = DISP_SHADOW_FRAGMENT_HANDLE_INVALID; return h; }
//----------------------------------------------------------------------------- // Purpose: // Input : framenumber - //----------------------------------------------------------------------------- CFrameSnapshot* CFrameSnapshotManager::TakeTickSnapshot( int ticknumber ) { CFrameSnapshot *snap = new CFrameSnapshot; snap->AddReference(); snap->m_nTickNumber = ticknumber; memset( snap->m_Entities, 0, sizeof( snap->m_Entities ) ); edict_t *ed; for ( int i = 0; i < sv.num_edicts; i++ ) { CFrameSnapshotEntry *entry = &snap->m_Entities[ i ]; ed = &sv.edicts[ i ]; // FIXME, this will cause EF_NODRAW entities to behave like // they need to be deleted from the client, even though // the client was never sent the entity entry->m_bExists = ed->m_pEnt && !ed->free; entry->m_nSerialNumber = ed->serial_number; entry->m_ClassName = ed->classname; } // Blat out packed data memset( snap->m_pPackedData, 0xFF, MAX_EDICTS * sizeof(PackedEntityHandle_t) ); snap->m_ListIndex = m_FrameSnapshots.AddToTail( snap ); return snap; }
//----------------------------------------------------------------------------- // 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 ); } }
//----------------------------------------------------------------------------- // Creates a new renderable //----------------------------------------------------------------------------- void CClientLeafSystem::NewRenderable( IClientRenderable* pRenderable, RenderGroup_t type, int flags ) { Assert( pRenderable ); Assert( pRenderable->RenderHandle() == INVALID_CLIENT_RENDER_HANDLE ); ClientRenderHandle_t handle = m_Renderables.AddToTail(); RenderableInfo_t &info = m_Renderables[handle]; // We need to know if it's a brush model for shadows int modelType = modelinfo->GetModelType( pRenderable->GetModel() ); if (modelType == mod_brush) { flags |= RENDER_FLAGS_BRUSH_MODEL; } else if ( modelType == mod_studio ) { flags |= RENDER_FLAGS_STUDIO_MODEL; } info.m_pRenderable = pRenderable; info.m_RenderFrame = -1; info.m_RenderFrame2 = -1; info.m_FirstShadow = m_ShadowsOnRenderable.InvalidIndex(); info.m_LeafList = m_RenderablesInLeaf.InvalidIndex(); info.m_Flags = flags; info.m_RenderGroup = (unsigned char)type; info.m_EnumCount = 0; info.m_RenderLeaf = 0xFFFF; if ( IsViewModelRenderGroup( (RenderGroup_t)info.m_RenderGroup ) ) { AddToViewModelList( handle ); } pRenderable->RenderHandle() = handle; }
CGroundLine::~CGroundLine() { s_GroundLines.Remove( m_ListHandle ); m_vStart.Init(); m_vEnd.Init(); m_LineWidth = 1; }
void CFrameSnapshotManager::DeleteFrameSnapshot( CFrameSnapshot* pSnapshot ) { // Decrement reference counts of all packed entities for (int i = 0; i < MAX_EDICTS; ++i) { if (pSnapshot->m_pPackedData[i] != m_PackedEntities.InvalidIndex()) { if (--m_PackedEntities[ pSnapshot->m_pPackedData[i] ].m_ReferenceCount <= 0) { DestroyPackedEntity( pSnapshot->m_pPackedData[i] ); } } } m_FrameSnapshots.Remove( pSnapshot->m_ListIndex ); delete pSnapshot; }
void CClientLeafSystem::RemoveShadow( ClientLeafShadowHandle_t handle ) { // Remove the shadow from all leaves + renderables... RemoveShadowFromLeaves( handle ); RemoveShadowFromRenderables( handle ); // Blow away the handle m_Shadows.Remove( handle ); }