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 );
}
