//--------------------------------------------------------------------------
void Server::Disconnect(VeUInt32 u32ClientID)
{
ClientAgent** it = m_kAgentMap.Find(u32ClientID);
if(it)
{
(*it)->DetachAllEntities();
(*it)->OnDisconnect();
m_kAgentMap.Remove(u32ClientID);
VE_SAFE_DELETE(*it);
}
}
//--------------------------------------------------------------------------
void VeThread::TermPerThread() noexcept
{
# ifdef VE_USE_THREAD_LOCAL
VE_SAFE_DELETE(s_pkSingleton);
# else
VE_DELETE((VeThreadLocalSingleton*)pthread_getspecific(s_keySingleton));
# ifdef VE_MEM_DEBUG
delete (vtd::vector<VeDeleteCallParams>*)pthread_getspecific(g_keyDeleteStack);
# endif
# endif
}
void UILayerManager::ClearLayers()
{
PopAllLayers();
SetMainLayer(NULL, false);
m_kLayerMap.Clear();
for(VeVector<UILayer*>::iterator it = m_kLayerSet.Begin(); it != m_kLayerSet.End(); ++it)
{
VE_SAFE_DELETE(*it);
}
m_kLayerSet.Clear();
}
//--------------------------------------------------------------------------
void ServerAgent::EntityDestory(BitStream& kStream)
{
VEString kName;
kStream >> kName;
VeStringMap<EntityC*>::iterator it = m_kEntityMap.Find(kName);
if(it)
{
(*it)->OnUnload();
m_kEntityMap.Remove(kName);
VE_SAFE_DELETE(*it);
}
}
//--------------------------------------------------------------------------
void VeTermOpenGL()
{
# ifdef VE_GLX
_glXQueryExtension = NULL;
_glXChooseVisual = NULL;
_glXCreateContext = NULL;
_glXMakeCurrent = NULL;
_glXSwapBuffers = NULL;
# endif
VE_ASSERT(g_pkOpenGL);
g_pkOpenGL->Unload();
VE_SAFE_DELETE(g_pkOpenGL);
}
//--------------------------------------------------------------------------
void ServerManager::Clear()
{
m_kServerMap.Clear();
m_kServerList.BeginIterator();
while(!m_kServerList.IsEnd())
{
Server* pkServer = m_kServerList.GetIterNode()->m_tContent;
m_kServerList.Next();
VE_ASSERT(pkServer);
VE_SAFE_DELETE(pkServer);
}
m_kServerList.Clear();
}
//--------------------------------------------------------------------------
void ServerAgent::Reset()
{
m_kServerID = UNASSIGNED_SYSTEM_ADDRESS;
m_bServerConnected = false;
m_kEntityMap.Clear();
m_kEntityList.BeginIterator();
while(!m_kEntityList.IsEnd())
{
EntityC* pkEntity = m_kEntityList.GetIterNode()->m_tContent;
m_kEntityList.Next();
VE_SAFE_DELETE(pkEntity);
}
VE_ASSERT(m_kEntityList.Empty());
}
//--------------------------------------------------------------------------
LoadEntResult Server::LoadEntity(const VeChar8* pcName,
const VeChar8* pcSearchIndex, EntityS** ppkOut)
{
VeUInt32 u32Type = _EntNameToType(pcName);
if(u32Type == VE_INFINITE)
{
if(ppkOut) *ppkOut = NULL;
return LOAD_ENT_TYPE_NOT_EXIST;
}
else
{
if(u32Type >= m_kEntityCacheArray.Size())
{
m_kEntityCacheArray.Resize(u32Type + 1);
}
EntityCache& kCache = m_kEntityCacheArray[u32Type];
VeStringMap<EntityS*>::iterator it = kCache.m_kIndexMap.Find(pcSearchIndex);
if(it)
{
if(ppkOut) *ppkOut = *it;
return LOAD_ENT_EXIST;
}
else
{
EntityS* pkEnt = NewEntity(pcName, pcSearchIndex);
if(pkEnt)
{
if(pkEnt->OnLoad())
{
pkEnt->m_pkCache = &kCache;
kCache.m_kIndexMap[pcSearchIndex] = pkEnt;
kCache.m_kWildEntities.AttachBack(pkEnt->m_kServerNode);
if(ppkOut) *ppkOut = pkEnt;
return LOAD_ENT_S_OK;
}
else
{
VE_SAFE_DELETE(pkEnt);
if(ppkOut) *ppkOut = NULL;
return LOAD_ENT_E_FAIL;
}
}
else
{
if(ppkOut) *ppkOut = NULL;
return LOAD_ENT_E_FAIL;
}
}
}
}
//--------------------------------------------------------------------------
void VeMaterialManager::DestoryRenderNode(const VeChar8* pcName)
{
VeStringMap<VeUInt32>::iterator it = m_kRenderNodeMap.Find(pcName);
if(it)
{
VE_SAFE_DELETE(m_kRenderNodeSet[*it]);
if((*it) < (m_kRenderNodeSet.Size() - 1))
{
VeRenderNode* pkNode = m_kRenderNodeSet.Back();
m_kRenderNodeMap[pkNode->m_kName] = *it;
m_kRenderNodeSet[*it] = pkNode;
}
m_kRenderNodeMap.Remove(pcName);
m_kRenderNodeSet.PopBack();
}
}
void UILayerManager::DelLayer(const VeChar8* pcName)
{
if(pcName)
{
VeUInt32* it = m_kLayerMap.Find(pcName);
if(it)
{
VeUInt32 u32Index = *it;
if(u32Index < (m_kLayerSet.Size() - 1))
{
UILayer* pkLayer = m_kLayerSet[u32Index];
UILayer* pkMove = m_kLayerSet.Back();
m_kLayerMap[pkMove->GetName()] = u32Index;
m_kLayerSet[u32Index] = pkMove;
m_kLayerSet.Back() = pkLayer;
}
m_kLayerMap.Remove(pcName);
VE_SAFE_DELETE(m_kLayerSet.Back());
m_kLayerSet.PopBack();
}
}
}
void veThreadPool::stop()
{
if (_stop) return;
_stop = true;
{
std::unique_lock<std::mutex> lock(_queueMutex);
while (_tasks.size())
_tasks.pop();
//while (_taskCallBacks.size())
// _taskCallBacks.pop();
}
_condition.notify_all();
for (auto &thread : _threadPool) {
thread->join();
}
for (auto &thread : _threadPool) {
VE_SAFE_DELETE(thread);
}
_threadPool.clear();
}
//--------------------------------------------------------------------------
void Client::Clear()
{
VE_AUTO_LOCK_MUTEX(m_kMutex);
m_kConnectionMap.Clear();
m_kConnectOnList.BeginIterator();
while(!m_kConnectOnList.IsEnd())
{
Connection* pkConnect = m_kConnectOnList.GetIterNode()->m_tContent;
m_kConnectOnList.Next();
VE_ASSERT(pkConnect);
pkConnect->Disconnect();
}
VE_ASSERT(m_kConnectOnList.Empty());
m_kConnectOffList.BeginIterator();
while(!m_kConnectOffList.IsEnd())
{
Connection* pkConnect = m_kConnectOffList.GetIterNode()->m_tContent;
m_kConnectOffList.Next();
VE_ASSERT(pkConnect);
VE_SAFE_DELETE(pkConnect);
}
VE_ASSERT(m_kConnectOffList.Empty());
}
veViewerDesktop::~veViewerDesktop()
{
#if VE_PLATFORM == VE_PLATFORM_WIN32
VE_SAFE_DELETE(_glContext);
#endif
}
//--------------------------------------------------------------------------
Connection::~Connection()
{
VE_SAFE_DELETE(m_pkServer);
}
veApplicationAndroid::~veApplicationAndroid() {
stop();
for (auto &viewer : _viewerList) {
VE_SAFE_DELETE(viewer);
}
}
