From e184a40bd12453c92696f1ca9e15a616d0b2b389 Mon Sep 17 00:00:00 2001 From: Jonathan <30329245+CookStar@users.noreply.github.com> Date: Sun, 5 Dec 2021 23:26:46 +0900 Subject: [PATCH 1/2] Enhanced CollisionHash. --- .../source-python/entities/collisions.py | 22 +- .../modules/entities/entities_collisions.cpp | 427 +++++++++++++++--- .../modules/entities/entities_collisions.h | 73 ++- .../entities/entities_collisions_wrap.cpp | 200 ++++++-- 4 files changed, 590 insertions(+), 132 deletions(-) mode change 100644 => 100755 addons/source-python/packages/source-python/entities/collisions.py mode change 100644 => 100755 src/core/modules/entities/entities_collisions.cpp mode change 100644 => 100755 src/core/modules/entities/entities_collisions.h mode change 100644 => 100755 src/core/modules/entities/entities_collisions_wrap.cpp diff --git a/addons/source-python/packages/source-python/entities/collisions.py b/addons/source-python/packages/source-python/entities/collisions.py old mode 100644 new mode 100755 index 1ad6b3b52..e295d346b --- a/addons/source-python/packages/source-python/entities/collisions.py +++ b/addons/source-python/packages/source-python/entities/collisions.py @@ -19,30 +19,30 @@ # ============================================================================= # Source.Python Imports # Entities -from _entities._collisions import BaseCollisionHash from _entities._collisions import CollisionHash from _entities._collisions import CollisionManager +from _entities._collisions import CollisionTable from _entities._collisions import collision_manager # ============================================================================= # >> ALL DECLARATION # ============================================================================= -__all__ = [ - 'BaseCollisionHash', - 'CollisionHash', - 'CollisionHook', - 'CollisionManager', - 'collision_manager', -] +__all__ = ('SOLID_MASKS', + 'CollisionHash', + 'CollisionHook', + 'CollisionManager', + 'CollisionTable', + 'collision_manager', + ) # ============================================================================= # >> INITIALIZATION # ============================================================================= -# Inject AutoUnload into BaseCollisionHash's hierarchy. -if not issubclass(BaseCollisionHash, AutoUnload): - BaseCollisionHash.__bases__ = (AutoUnload,) + BaseCollisionHash.__bases__ +# Inject AutoUnload into CollisionHash's hierarchy. +if not issubclass(CollisionHash, AutoUnload): + CollisionHash.__bases__ = (AutoUnload,) + CollisionHash.__bases__ # ============================================================================= diff --git a/src/core/modules/entities/entities_collisions.cpp b/src/core/modules/entities/entities_collisions.cpp old mode 100644 new mode 100755 index 161d0efbb..3d68a034b --- a/src/core/modules/entities/entities_collisions.cpp +++ b/src/core/modules/entities/entities_collisions.cpp @@ -41,6 +41,7 @@ //----------------------------------------------------------------------------- extern IEngineTrace *enginetrace; extern IPhysics *physics; +extern IServerTools *servertools; extern CGlobalVars *gpGlobals; @@ -118,7 +119,7 @@ void CCollisionManager::Finalize() m_bInitialized = false; } -void CCollisionManager::RegisterHash(ICollisionHash *pHash) +void CCollisionManager::RegisterHash(CCollisionHash *pHash) { if (m_vecHashes.HasElement(pHash)) { BOOST_RAISE_EXCEPTION( @@ -131,7 +132,7 @@ void CCollisionManager::RegisterHash(ICollisionHash *pHash) m_vecHashes.AddToTail(pHash); } -void CCollisionManager::UnregisterHash(ICollisionHash *pHash) +void CCollisionManager::UnregisterHash(CCollisionHash *pHash) { if (!m_vecHashes.FindAndRemove(pHash)) { return; @@ -160,7 +161,7 @@ void CCollisionManager::OnNetworkedEntityCreated(object oEntity) void CCollisionManager::OnNetworkedEntityDeleted(CBaseEntity *pEntity) { FOR_EACH_VEC(m_vecHashes, i) { - m_vecHashes[i]->RemovePairs((void *)pEntity); + m_vecHashes[i]->Erase(pEntity); } } @@ -422,7 +423,7 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten } FOR_EACH_VEC(pManager->m_vecHashes, i) { - if (pManager->m_vecHashes[i]->HasPair((void *)scope.m_pFilter->m_pPassEnt, (void *)pHandleEntity)) { + if (pManager->m_vecHashes[i]->IsSet(scope.m_uiIndex, uiIndex)) { scope.m_pCache->SetResult(uiIndex, false); return false; } @@ -499,43 +500,138 @@ CCollisionCache *CCollisionManager::GetCache(unsigned int uiIndex) //----------------------------------------------------------------------------- -// ICollisionHash class. +// CCollisionCache class. //----------------------------------------------------------------------------- -ICollisionHash::ICollisionHash() +bool CCollisionCache::HasResult(unsigned int uiIndex) { - static CCollisionManager *pManager = GetCollisionManager(); - pManager->RegisterHash(this); + return IsBitSet(uiIndex); } -ICollisionHash::~ICollisionHash() +bool CCollisionCache::GetResult(unsigned int uiIndex) { - UnloadInstance(); + return m_vecCache.IsBitSet(uiIndex); } -void ICollisionHash::UnloadInstance() +void CCollisionCache::SetResult(unsigned int uiIndex, bool bResult) { - static CCollisionManager *pManager = GetCollisionManager(); - pManager->UnregisterHash(this); + Set(uiIndex); + m_vecCache.Set((int)uiIndex, bResult); } //----------------------------------------------------------------------------- -// CCollisionCache class. +// CCollisionTable class. //----------------------------------------------------------------------------- -bool CCollisionCache::HasResult(unsigned int uiIndex) +CCollisionTable::CCollisionTable(unsigned int uiActivatorIndex, CBaseEntity *pActivator): + m_uiActivatorIndex(uiActivatorIndex) { - return IsBitSet(uiIndex); + if (((CBaseEntityWrapper *)pActivator)->IsPlayer()) + { + static object Player = import("players.entity").attr("Player"); + m_oActivator = Player(uiActivatorIndex); + } + else + { + static object Entity = import("entities.entity").attr("Entity"); + m_oActivator = Entity(uiActivatorIndex); + } } -bool CCollisionCache::GetResult(unsigned int uiIndex) +bool CCollisionTable::__getitem__(unsigned int uiIndex) { - return m_vecCache.IsBitSet(uiIndex); + edict_t* pEdict; + if(!EdictFromIndex(uiIndex, pEdict)) + return false; + + return IsBitSet((int)uiIndex); } -void CCollisionCache::SetResult(unsigned int uiIndex, bool bResult) +bool CCollisionTable::__setitem__(unsigned int uiIndex, bool bDisable) { - Set(uiIndex); - m_vecCache.Set((int)uiIndex, bResult); + if (uiIndex == m_uiActivatorIndex) + return false; + + edict_t* pEdict; + if(!EdictFromIndex(uiIndex, pEdict)) + return false; + + Set((int)uiIndex, bDisable); + return true; +} + +void CCollisionTable::Disable(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + + if (uiIndex == m_uiActivatorIndex) + return; + + Set((int)uiIndex, true); +} + +void CCollisionTable::Reset(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + Set((int)uiIndex, false); +} + +bool CCollisionTable::IsDisabled(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + return IsBitSet((int)uiIndex); +} + +void CCollisionTable::DisableAll() +{ + CBaseEntity *pBaseEntity = (CBaseEntity *)servertools->FirstEntity(); + while (pBaseEntity) + { + unsigned int uiIndex; + if (IndexFromBaseEntity(pBaseEntity, uiIndex) && uiIndex != m_uiActivatorIndex) + Set((int)uiIndex, true); + + pBaseEntity = (CBaseEntity *)servertools->NextEntity(pBaseEntity); + } +} + +int CCollisionTable::Count() +{ + int count = 0; + for (int i = 0; i < MAX_EDICTS; ++i) + { + if (IsBitSet(i)) + ++count; + } + + return count; +} + +list CCollisionTable::GetDisabled() +{ + list oEntities; + + if (IsAllClear()) + return oEntities; + + for (int i = 0; i < MAX_EDICTS; ++i) + { + CBaseEntity *pBaseEntity; + if (IsBitSet(i) && BaseEntityFromIndex((unsigned int)i, pBaseEntity)) + { + if (((CBaseEntityWrapper *)pBaseEntity)->IsPlayer()) + { + static object Player = import("players.entity").attr("Player"); + oEntities.append(Player((unsigned int)i)); + } + else + { + static object Entity = import("entities.entity").attr("Entity"); + oEntities.append(Entity((unsigned int)i)); + } + } + } + + return oEntities; } @@ -544,84 +640,293 @@ void CCollisionCache::SetResult(unsigned int uiIndex, bool bResult) //----------------------------------------------------------------------------- CCollisionHash::CCollisionHash() { - m_pHash = physics->CreateObjectPairHash(); + static CCollisionManager *pManager = GetCollisionManager(); + pManager->RegisterHash(this); +} - if (!m_pHash) { - BOOST_RAISE_EXCEPTION( - PyExc_RuntimeError, - "Failed to create a collision hash." - ) +CCollisionHash::~CCollisionHash() +{ + UnloadInstance(); +} + +boost::shared_ptr CCollisionHash::GetCollisionTable(CBaseEntity *pActivator) +{ + unsigned int uiActivatorIndex = ExcIndexFromBaseEntity(pActivator); + + CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); + if (it != m_mapHash.end()) + return it->second; + + boost::shared_ptr pCollisionTable(new CCollisionTable(uiActivatorIndex, pActivator)); + m_mapHash.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); + + return pCollisionTable; +} + +boost::shared_ptr CCollisionHash::GetCollisionTable(unsigned int uiActivatorIndex) +{ + CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); + if (it != m_mapHash.end()) + return it->second; + + CBaseEntity *pActivator = ExcBaseEntityFromIndex(uiActivatorIndex); + + boost::shared_ptr pCollisionTable(new CCollisionTable(uiActivatorIndex, pActivator)); + m_mapHash.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); + + return pCollisionTable; +} + +void CCollisionHash::DisableFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) +{ + GetCollisionTable(pActivator)->Disable(pEntity); +} + +void CCollisionHash::ResetFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) +{ + GetCollisionTable(pActivator)->Reset(pEntity); +} + +bool CCollisionHash::IsDisabledFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) +{ + return GetCollisionTable(pActivator)->IsDisabled(pEntity); +} + +void CCollisionHash::Disable(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + + CBaseEntity *pBaseEntity = (CBaseEntity *)servertools->FirstEntity(); + while (pBaseEntity) + { + unsigned int uiActivatorIndex; + if (IndexFromBaseEntity(pBaseEntity, uiActivatorIndex) && uiIndex != uiActivatorIndex) + { + CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); + if (it != m_mapHash.end()) + { + it->second->Set((int)uiIndex, true); + } + else + { + boost::shared_ptr pCollisionTable(new CCollisionTable(uiActivatorIndex, pBaseEntity)); + m_mapHash.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); + pCollisionTable->Set((int)uiIndex, true); + } + } + + pBaseEntity = (CBaseEntity *)servertools->NextEntity(pBaseEntity); } } -CCollisionHash::~CCollisionHash() +void CCollisionHash::Reset(CBaseEntity *pEntity) { - if (!m_pHash) { - return; + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + + for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + { + it->second->Set((int)uiIndex, false); } +} - physics->DestroyObjectPairHash(m_pHash); +bool CCollisionHash::IsDisabled(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + + for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + { + if (it->second->IsBitSet((int)uiIndex)) + return true; + } + return false; } -void CCollisionHash::AddPair(void *pEntity, void *pOther) +int CCollisionHash::CountDisabled(CBaseEntity *pEntity) { - if (!IsValidNetworkedEntityPointer(pEntity) || !IsValidNetworkedEntityPointer(pOther)) { - BOOST_RAISE_EXCEPTION( - PyExc_ValueError, - "Given entity pointer invalid or not networked." - ) + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); + + int count = 0; + for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + { + if (it->second->IsBitSet((int)uiIndex)) + ++count; } + return count; +} + +list CCollisionHash::GetDisabledActivator(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); - m_pHash->AddObjectPair(pEntity, pOther); + list oEntities; + + for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + { + boost::shared_ptr pCollisionTable = it->second; + if (pCollisionTable->IsBitSet((int)uiIndex)) + oEntities.append(pCollisionTable->m_oActivator); + } + + return oEntities; } -void CCollisionHash::RemovePair(void *pEntity, void *pOther) +void CCollisionHash::AddPair(CBaseEntity *pEntity, CBaseEntity *pOther) { - m_pHash->RemoveObjectPair(pEntity, pOther); + if (pEntity == pOther) + return; + + boost::shared_ptr pEntityTable = GetCollisionTable(pEntity); + boost::shared_ptr pOtherTable = GetCollisionTable(pOther); + + pEntityTable->Set((int)pOtherTable->m_uiActivatorIndex, true); + pOtherTable->Set((int)pEntityTable->m_uiActivatorIndex, true); } -void CCollisionHash::RemovePairs(void *pEntity) +void CCollisionHash::RemovePair(CBaseEntity *pEntity, CBaseEntity *pOther) { - m_pHash->RemoveAllPairsForObject(pEntity); + unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); + unsigned int uiOtherIndex = ExcIndexFromBaseEntity(pOther); + + CollisionHashMap_t::iterator it; + + it = m_mapHash.find(uiEntityIndex); + if (it != m_mapHash.end()) + it->second->Set((int)uiOtherIndex, false); + + it = m_mapHash.find(uiOtherIndex); + if (it != m_mapHash.end()) + it->second->Set((int)uiEntityIndex, false); } -bool CCollisionHash::Contains(void *pEntity) +bool CCollisionHash::HasPair(CBaseEntity *pEntity, CBaseEntity *pOther) { - return m_pHash->IsObjectInHash(pEntity); + unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); + unsigned int uiOtherIndex = ExcIndexFromBaseEntity(pOther); + + CollisionHashMap_t::iterator it; + + it = m_mapHash.find(uiEntityIndex); + if (it != m_mapHash.end() && !it->second->IsBitSet((int)uiOtherIndex)) + return false; + + it = m_mapHash.find(uiOtherIndex); + if (it != m_mapHash.end() && !it->second->IsBitSet((int)uiEntityIndex)) + return false; + + return true; } -bool CCollisionHash::HasPair(void *pEntity, void *pOther) +void CCollisionHash::RemovePairs(CBaseEntity *pEntity) { - return m_pHash->IsObjectPairInHash(pEntity, pOther); + unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); + + CollisionHashMap_t::iterator it = m_mapHash.find(uiEntityIndex); + if (it != m_mapHash.end()) + { + boost::shared_ptr pEntityTable = it->second; + + for (unsigned int uiOtherIndex = 0; uiOtherIndex < MAX_EDICTS; ++uiOtherIndex) { + if (pEntityTable->IsBitSet((int)uiOtherIndex)) + { + CollisionHashMap_t::iterator it = m_mapHash.find(uiOtherIndex); + if (it != m_mapHash.end()) + { + boost::shared_ptr pOtherTable = it->second; + if (pOtherTable->IsBitSet((int)uiEntityIndex)) + { + pEntityTable->Set((int)uiOtherIndex, false); + pOtherTable->Set((int)uiEntityIndex, false); + } + } + } + } + } } -int CCollisionHash::GetCount(void *pEntity) +int CCollisionHash::CountPairs(CBaseEntity *pEntity) { - return m_pHash->GetPairCountForObject(pEntity); + unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); + + int count = 0; + CollisionHashMap_t::iterator it = m_mapHash.find(uiEntityIndex); + if (it != m_mapHash.end()) + { + boost::shared_ptr pEntityTable = it->second; + + for (unsigned int uiOtherIndex = 0; uiOtherIndex < MAX_EDICTS; ++uiOtherIndex) { + if (pEntityTable->IsBitSet((int)uiOtherIndex)) + { + CollisionHashMap_t::iterator it = m_mapHash.find(uiOtherIndex); + if (it != m_mapHash.end() && it->second->IsBitSet((int)uiEntityIndex)) + ++count; + } + } + } + + return count; } -list CCollisionHash::GetPairs(void *pEntity) +list CCollisionHash::GetPairs(CBaseEntity *pEntity) { + unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); + list oEntities; - int nCount = m_pHash->GetPairCountForObject(pEntity); + CollisionHashMap_t::iterator it = m_mapHash.find(uiEntityIndex); + if (it != m_mapHash.end()) + { + boost::shared_ptr pEntityTable = it->second; + + for (unsigned int uiOtherIndex = 0; uiOtherIndex < MAX_EDICTS; ++uiOtherIndex) { + if (pEntityTable->IsBitSet((int)uiOtherIndex)) + { + CollisionHashMap_t::iterator it = m_mapHash.find(uiOtherIndex); + if (it != m_mapHash.end()) + { + boost::shared_ptr pOtherTable = it->second; + if (pOtherTable->IsBitSet((int)uiEntityIndex)) + { + oEntities.append(pOtherTable->m_oActivator); + } + } + } + } + } - if (!nCount) { - return oEntities; + return oEntities; +} + +void CCollisionHash::Clear() +{ + for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + { + it->second->ClearAll(); } +} - void **ppEntities = (void **)stackalloc(nCount * sizeof(void *)); - m_pHash->GetPairListForObject(pEntity, nCount, ppEntities); +inline bool CCollisionHash::IsSet(unsigned int uiActivatorIndex, unsigned int uiOtherIndex) +{ + CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); + if (it != m_mapHash.end() && it->second->IsBitSet((int)uiOtherIndex)) + return true; - for (int i = 0; i < nCount; ++i) { - pEntity = ppEntities[i]; - if (!pEntity) { - continue; - } + return false; +} + +inline void CCollisionHash::Erase(CBaseEntity *pEntity) +{ + unsigned int uiIndex = ((CBaseEntityWrapper *)pEntity)->GetIndex(); + m_mapHash.erase(uiIndex); - oEntities.append(pEntity); + for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + { + it->second->Set((int)uiIndex, false); } +} - return oEntities; +void CCollisionHash::UnloadInstance() +{ + static CCollisionManager *pManager = GetCollisionManager(); + pManager->UnregisterHash(this); } diff --git a/src/core/modules/entities/entities_collisions.h b/src/core/modules/entities/entities_collisions.h old mode 100644 new mode 100755 index 4b0bf0eeb..a547d1bbd --- a/src/core/modules/entities/entities_collisions.h +++ b/src/core/modules/entities/entities_collisions.h @@ -50,6 +50,7 @@ // Forward declarations. //----------------------------------------------------------------------------- struct CollisionHookData_t; +class CCollisionTable; class CCollisionCache; @@ -62,6 +63,9 @@ class CCollisionCache; typedef boost::unordered_map CollisionHooksMap_t; +typedef CBitVec CollisionTable_t; +typedef boost::unordered_map> CollisionHashMap_t; + typedef CBitVec CollisionCache_t; typedef boost::unordered_map CollisionCacheMap_t; @@ -105,49 +109,70 @@ struct CollisionHookData_t //----------------------------------------------------------------------------- -// ICollisionHash class. +// CCollisionTable class. //----------------------------------------------------------------------------- -class ICollisionHash +class CCollisionTable : public CollisionTable_t { public: - ICollisionHash(); - virtual ~ICollisionHash(); + CCollisionTable(unsigned int uiActivatorIndex, CBaseEntity *pActivator); - virtual void AddPair(void *pEntity, void *pOther) = 0; - virtual void RemovePair(void *pEntity, void *pOther) = 0; - virtual void RemovePairs(void *pEntity) = 0; + bool __getitem__(unsigned int uiIndex); + bool __setitem__(unsigned int uiIndex, bool bDisable); - virtual bool Contains(void *pEntity) = 0; - virtual bool HasPair(void *pEntity, void *pOther) = 0; + void Disable(CBaseEntity *pEntity); + void Reset(CBaseEntity *pEntity); + bool IsDisabled(CBaseEntity *pEntity); - virtual int GetCount(void *pEntity) = 0; - virtual list GetPairs(void *pEntity) = 0; + void DisableAll(); - void UnloadInstance(); + int Count(); + list GetDisabled(); + + unsigned int m_uiActivatorIndex; + object m_oActivator; }; //----------------------------------------------------------------------------- // CCollisionHash class. //----------------------------------------------------------------------------- -class CCollisionHash : public ICollisionHash +class CCollisionHash { public: CCollisionHash(); ~CCollisionHash(); - void AddPair(void *pEntity, void *pOther); - void RemovePair(void *pEntity, void *pOther); - void RemovePairs(void *pEntity); + boost::shared_ptr GetCollisionTable(CBaseEntity *pActivator); + boost::shared_ptr GetCollisionTable(unsigned int uiActivatorIndex); + + void DisableFrom(CBaseEntity *pEntity, CBaseEntity *pActivator); + void ResetFrom(CBaseEntity *pEntity, CBaseEntity *pActivator); + bool IsDisabledFrom(CBaseEntity *pEntity, CBaseEntity *pActivator); + + void Disable(CBaseEntity *pEntity); + void Reset(CBaseEntity *pEntity); + bool IsDisabled(CBaseEntity *pEntity); - bool Contains(void *pEntity); - bool HasPair(void *pEntity, void *pOther); + int CountDisabled(CBaseEntity *pEntity); + list GetDisabledActivator(CBaseEntity *pEntity); - int GetCount(void *pEntity); - list GetPairs(void *pEntity); + void AddPair(CBaseEntity *pEntity, CBaseEntity *pOther); + void RemovePair(CBaseEntity *pEntity, CBaseEntity *pOther); + bool HasPair(CBaseEntity *pEntity, CBaseEntity *pOther); + + void RemovePairs(CBaseEntity *pEntity); + int CountPairs(CBaseEntity *pEntity); + list GetPairs(CBaseEntity *pEntity); + + void Clear(); + + bool IsSet(unsigned int uiActivatorIndex, unsigned int uiOtherIndex); + void Erase(CBaseEntity *pEntity); + + void UnloadInstance(); private: - IPhysicsObjectPairHash *m_pHash; + CollisionHashMap_t m_mapHash; }; @@ -183,8 +208,8 @@ class CCollisionManager void Initialize(); void Finalize(); - void RegisterHash(ICollisionHash *pHash); - void UnregisterHash(ICollisionHash *pHash); + void RegisterHash(CCollisionHash *pHash); + void UnregisterHash(CCollisionHash *pHash); void OnNetworkedEntityCreated(object oEntity); void OnNetworkedEntityDeleted(CBaseEntity *pEntity); @@ -212,7 +237,7 @@ class CCollisionManager private: bool m_bInitialized; unsigned int m_uiRefCount; - CUtlVector m_vecHashes; + CUtlVector m_vecHashes; CollisionHooksMap_t m_mapHooks; std::vector m_vecScopes; diff --git a/src/core/modules/entities/entities_collisions_wrap.cpp b/src/core/modules/entities/entities_collisions_wrap.cpp old mode 100644 new mode 100755 index dee2ff995..6cb18f4a2 --- a/src/core/modules/entities/entities_collisions_wrap.cpp +++ b/src/core/modules/entities/entities_collisions_wrap.cpp @@ -36,7 +36,7 @@ // Forward declarations. //----------------------------------------------------------------------------- static void export_collision_manager(scope); -static void export_base_collision_hash(scope); +static void export_collision_table(scope); static void export_collision_hash(scope); @@ -46,7 +46,7 @@ static void export_collision_hash(scope); DECLARE_SP_SUBMODULE(_entities, _collisions) { export_collision_manager(_collisions); - export_base_collision_hash(_collisions); + export_collision_table(_collisions); export_collision_hash(_collisions); } @@ -84,69 +84,197 @@ void export_collision_manager(scope _collisions) //----------------------------------------------------------------------------- -// Exports ICollisionHash. +// Exports CCollisionTable. //----------------------------------------------------------------------------- -void export_base_collision_hash(scope _collisions) +void export_collision_table(scope _collisions) { - class_ BaseCollisionHash("BaseCollisionHash", no_init); + class_, boost::noncopyable> CollisionTable("CollisionTable", no_init); // Methods... - BaseCollisionHash.def( + CollisionTable.def( + "disable", + &CCollisionTable::Disable, + "Disables collision with the given entity." + ); + + CollisionTable.def( + "reset", + &CCollisionTable::Reset, + "Resets collision with the given entity." + ); + + CollisionTable.def( + "is_disabled", + &CCollisionTable::IsDisabled, + "Returns whether collision with the given entity is disabled." + ); + + CollisionTable.def( + "disable_all", + &CCollisionTable::DisableAll, + "Disables collision with all entities." + ); + + CollisionTable.def( + "clear", + &CCollisionTable::ClearAll, + "Resets collision with all entities." + ); + + CollisionTable.def( + "get_disabled", + &CCollisionTable::GetDisabled, + "Returns a list of entities with collision disabled." + ); + + CollisionTable.add_property( + "count", + &CCollisionTable::Count, + "Returns the amount of entities with collision disabled." + ); + + CollisionTable.def_readonly( + "activator", + &CCollisionTable::m_oActivator, + "Returns the activator entity that will disable collision." + ); + + // Special methods... + CollisionTable.def( + "__getitem__", + &CCollisionTable::__getitem__, + "Returns whether collision is disabled by an entity index." + ); + + CollisionTable.def( + "__setitem__", + &CCollisionTable::__setitem__, + "Set collision by entity index." + ); + + CollisionTable.def( + "__contains__", + &CCollisionTable::IsDisabled, + "Returns whether collision with the given entity is disabled." + ); +} + + +//----------------------------------------------------------------------------- +// Exports CCollisionHash. +//----------------------------------------------------------------------------- +void export_collision_hash(scope _collisions) +{ + class_ CollisionHash("CollisionHash"); + + // Methods... + CollisionHash.def( + "get_collision_table", + GET_METHOD(boost::shared_ptr, CCollisionHash, GetCollisionTable, CBaseEntity *), + "Returns the CollisionTable for the given activator entity." + ); + + CollisionHash.def( + "disable_from", + &CCollisionHash::DisableFrom, + "Disables collision of the given entity from the activator entity." + ); + + CollisionHash.def( + "reset_from", + &CCollisionHash::ResetFrom, + "Resets collision of the given entity from the activator entity." + ); + + CollisionHash.def( + "is_disabled_from", + &CCollisionHash::IsDisabledFrom, + "Returns whether collision of the given entity is disabled from the activator entity." + ); + + CollisionHash.def( + "disable", + &CCollisionHash::Disable, + "Disables collision of the given entity in all activator entities." + ); + + CollisionHash.def( + "reset", + &CCollisionHash::Reset, + "Resets collision of the given entity in all activator entities." + ); + + CollisionHash.def( + "is_disabled", + &CCollisionHash::IsDisabled, + "Returns whether collision of the given entity has been disabled for any activator entity." + ); + + CollisionHash.def( + "get_disabled_activator", + &CCollisionHash::GetDisabledActivator, + "Returns a list of activator entities with collision disabled for the given entity." + ); + + CollisionHash.def( "add_pair", - &ICollisionHash::AddPair, + &CCollisionHash::AddPair, "Adds the given entity pair to the hash." ); - BaseCollisionHash.def( + CollisionHash.def( "remove_pair", - &ICollisionHash::RemovePair, + &CCollisionHash::RemovePair, "Removes the given pair from the hash." ); - BaseCollisionHash.def( - "remove_pairs", - &ICollisionHash::RemovePairs, - "Removes all pairs associated with the given entity." - ); - - BaseCollisionHash.def( + CollisionHash.def( "has_pair", - &ICollisionHash::HasPair, + &CCollisionHash::HasPair, "Returns whether the given pair is in the hash." ); - BaseCollisionHash.def( - "get_count", - &ICollisionHash::GetCount, + CollisionHash.def( + "remove_pairs", + &CCollisionHash::RemovePairs, + "Removes all pairs associated with the given entity." + ); + + CollisionHash.def( + "count_pairs", + &CCollisionHash::CountPairs, "Returns the amount of pairs associated with the given entity." ); - BaseCollisionHash.def( + CollisionHash.def( "get_pairs", - &ICollisionHash::GetPairs, + &CCollisionHash::GetPairs, "Returns a list of all entities associated with the given entity." ); + CollisionHash.def( + "clear", + &CCollisionHash::Clear, + "Resets collision across all entities in all activator entities." + ); + // Special methods... - BaseCollisionHash.def( + CollisionHash.def( + "__getitem__", + GET_METHOD(boost::shared_ptr, CCollisionHash, GetCollisionTable, unsigned int), + "Returns the CollisionTable for the given activator entity index." + ); + + CollisionHash.def( "__contains__", - &ICollisionHash::Contains, - "Returns whether the given entity is in the hash." + &CCollisionHash::IsDisabled, + "Returns whether collision of the given entity has been disabled for any activator entity." ); // AutoUnload... - BaseCollisionHash.def( + CollisionHash.def( "_unload_instance", - &ICollisionHash::UnloadInstance, + &CCollisionHash::UnloadInstance, "Called when an instance is being unloaded." ); } - - -//----------------------------------------------------------------------------- -// Exports CCollisionHash. -//----------------------------------------------------------------------------- -void export_collision_hash(scope _collisions) -{ - class_ >("CollisionHash"); -} From 13a52be00f5b447b1d7b5907474ae4b75285def9 Mon Sep 17 00:00:00 2001 From: Jonathan <30329245+CookStar@users.noreply.github.com> Date: Thu, 9 Dec 2021 04:30:23 +0900 Subject: [PATCH 2/2] Fixed CCollisionFilter::HasPair. Changed CCollisionHash to CCollisionFilter. --- .../source-python/entities/collisions.py | 10 +- .../modules/entities/entities_collisions.cpp | 151 +++++++++--------- .../modules/entities/entities_collisions.h | 20 ++- .../entities/entities_collisions_wrap.cpp | 90 +++++------ 4 files changed, 134 insertions(+), 137 deletions(-) diff --git a/addons/source-python/packages/source-python/entities/collisions.py b/addons/source-python/packages/source-python/entities/collisions.py index e295d346b..7ae90ee6e 100755 --- a/addons/source-python/packages/source-python/entities/collisions.py +++ b/addons/source-python/packages/source-python/entities/collisions.py @@ -19,7 +19,7 @@ # ============================================================================= # Source.Python Imports # Entities -from _entities._collisions import CollisionHash +from _entities._collisions import CollisionFilter from _entities._collisions import CollisionManager from _entities._collisions import CollisionTable from _entities._collisions import collision_manager @@ -29,7 +29,7 @@ # >> ALL DECLARATION # ============================================================================= __all__ = ('SOLID_MASKS', - 'CollisionHash', + 'CollisionFilter', 'CollisionHook', 'CollisionManager', 'CollisionTable', @@ -40,9 +40,9 @@ # ============================================================================= # >> INITIALIZATION # ============================================================================= -# Inject AutoUnload into CollisionHash's hierarchy. -if not issubclass(CollisionHash, AutoUnload): - CollisionHash.__bases__ = (AutoUnload,) + CollisionHash.__bases__ +# Inject AutoUnload into CollisionFilter's hierarchy. +if not issubclass(CollisionFilter, AutoUnload): + CollisionFilter.__bases__ = (AutoUnload,) + CollisionFilter.__bases__ # ============================================================================= diff --git a/src/core/modules/entities/entities_collisions.cpp b/src/core/modules/entities/entities_collisions.cpp index 3d68a034b..ba9586334 100755 --- a/src/core/modules/entities/entities_collisions.cpp +++ b/src/core/modules/entities/entities_collisions.cpp @@ -40,7 +40,6 @@ // Externals. //----------------------------------------------------------------------------- extern IEngineTrace *enginetrace; -extern IPhysics *physics; extern IServerTools *servertools; extern CGlobalVars *gpGlobals; @@ -119,22 +118,22 @@ void CCollisionManager::Finalize() m_bInitialized = false; } -void CCollisionManager::RegisterHash(CCollisionHash *pHash) +void CCollisionManager::RegisterFilter(CCollisionFilter *pFilter) { - if (m_vecHashes.HasElement(pHash)) { + if (m_vecFilteres.HasElement(pFilter)) { BOOST_RAISE_EXCEPTION( PyExc_ValueError, - "The given hash is already registered." + "The given filter is already registered." ); } IncRef(); - m_vecHashes.AddToTail(pHash); + m_vecFilteres.AddToTail(pFilter); } -void CCollisionManager::UnregisterHash(CCollisionHash *pHash) +void CCollisionManager::UnregisterFilter(CCollisionFilter *pFilter) { - if (!m_vecHashes.FindAndRemove(pHash)) { + if (!m_vecFilteres.FindAndRemove(pFilter)) { return; } @@ -160,8 +159,8 @@ void CCollisionManager::OnNetworkedEntityCreated(object oEntity) void CCollisionManager::OnNetworkedEntityDeleted(CBaseEntity *pEntity) { - FOR_EACH_VEC(m_vecHashes, i) { - m_vecHashes[i]->Erase(pEntity); + FOR_EACH_VEC(m_vecFilteres, i) { + m_vecFilteres[i]->Erase(pEntity); } } @@ -422,8 +421,8 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten return true; } - FOR_EACH_VEC(pManager->m_vecHashes, i) { - if (pManager->m_vecHashes[i]->IsSet(scope.m_uiIndex, uiIndex)) { + FOR_EACH_VEC(pManager->m_vecFilteres, i) { + if (pManager->m_vecFilteres[i]->IsSet(scope.m_uiIndex, uiIndex)) { scope.m_pCache->SetResult(uiIndex, false); return false; } @@ -636,63 +635,63 @@ list CCollisionTable::GetDisabled() //----------------------------------------------------------------------------- -// CCollisionHash class. +// CCollisionFilter class. //----------------------------------------------------------------------------- -CCollisionHash::CCollisionHash() +CCollisionFilter::CCollisionFilter() { static CCollisionManager *pManager = GetCollisionManager(); - pManager->RegisterHash(this); + pManager->RegisterFilter(this); } -CCollisionHash::~CCollisionHash() +CCollisionFilter::~CCollisionFilter() { UnloadInstance(); } -boost::shared_ptr CCollisionHash::GetCollisionTable(CBaseEntity *pActivator) +boost::shared_ptr CCollisionFilter::GetCollisionTable(CBaseEntity *pActivator) { unsigned int uiActivatorIndex = ExcIndexFromBaseEntity(pActivator); - CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiActivatorIndex); + if (it != m_mapFilter.end()) return it->second; boost::shared_ptr pCollisionTable(new CCollisionTable(uiActivatorIndex, pActivator)); - m_mapHash.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); + m_mapFilter.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); return pCollisionTable; } -boost::shared_ptr CCollisionHash::GetCollisionTable(unsigned int uiActivatorIndex) +boost::shared_ptr CCollisionFilter::GetCollisionTable(unsigned int uiActivatorIndex) { - CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiActivatorIndex); + if (it != m_mapFilter.end()) return it->second; CBaseEntity *pActivator = ExcBaseEntityFromIndex(uiActivatorIndex); boost::shared_ptr pCollisionTable(new CCollisionTable(uiActivatorIndex, pActivator)); - m_mapHash.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); + m_mapFilter.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); return pCollisionTable; } -void CCollisionHash::DisableFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) +void CCollisionFilter::DisableFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) { GetCollisionTable(pActivator)->Disable(pEntity); } -void CCollisionHash::ResetFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) +void CCollisionFilter::ResetFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) { GetCollisionTable(pActivator)->Reset(pEntity); } -bool CCollisionHash::IsDisabledFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) +bool CCollisionFilter::IsDisabledFrom(CBaseEntity *pEntity, CBaseEntity *pActivator) { return GetCollisionTable(pActivator)->IsDisabled(pEntity); } -void CCollisionHash::Disable(CBaseEntity *pEntity) +void CCollisionFilter::Disable(CBaseEntity *pEntity) { unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); @@ -702,15 +701,15 @@ void CCollisionHash::Disable(CBaseEntity *pEntity) unsigned int uiActivatorIndex; if (IndexFromBaseEntity(pBaseEntity, uiActivatorIndex) && uiIndex != uiActivatorIndex) { - CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiActivatorIndex); + if (it != m_mapFilter.end()) { it->second->Set((int)uiIndex, true); } else { boost::shared_ptr pCollisionTable(new CCollisionTable(uiActivatorIndex, pBaseEntity)); - m_mapHash.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); + m_mapFilter.insert(std::make_pair(uiActivatorIndex, pCollisionTable)); pCollisionTable->Set((int)uiIndex, true); } } @@ -719,21 +718,21 @@ void CCollisionHash::Disable(CBaseEntity *pEntity) } } -void CCollisionHash::Reset(CBaseEntity *pEntity) +void CCollisionFilter::Reset(CBaseEntity *pEntity) { unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); - for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + for (CollisionFilterMap_t::iterator it = m_mapFilter.begin(); it != m_mapFilter.end(); ++it) { it->second->Set((int)uiIndex, false); } } -bool CCollisionHash::IsDisabled(CBaseEntity *pEntity) +bool CCollisionFilter::IsDisabled(CBaseEntity *pEntity) { unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); - for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + for (CollisionFilterMap_t::iterator it = m_mapFilter.begin(); it != m_mapFilter.end(); ++it) { if (it->second->IsBitSet((int)uiIndex)) return true; @@ -741,12 +740,12 @@ bool CCollisionHash::IsDisabled(CBaseEntity *pEntity) return false; } -int CCollisionHash::CountDisabled(CBaseEntity *pEntity) +int CCollisionFilter::CountDisabled(CBaseEntity *pEntity) { unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); int count = 0; - for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + for (CollisionFilterMap_t::iterator it = m_mapFilter.begin(); it != m_mapFilter.end(); ++it) { if (it->second->IsBitSet((int)uiIndex)) ++count; @@ -754,13 +753,13 @@ int CCollisionHash::CountDisabled(CBaseEntity *pEntity) return count; } -list CCollisionHash::GetDisabledActivator(CBaseEntity *pEntity) +list CCollisionFilter::GetDisabledActivator(CBaseEntity *pEntity) { unsigned int uiIndex = ExcIndexFromBaseEntity(pEntity); list oEntities; - for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + for (CollisionFilterMap_t::iterator it = m_mapFilter.begin(); it != m_mapFilter.end(); ++it) { boost::shared_ptr pCollisionTable = it->second; if (pCollisionTable->IsBitSet((int)uiIndex)) @@ -770,7 +769,7 @@ list CCollisionHash::GetDisabledActivator(CBaseEntity *pEntity) return oEntities; } -void CCollisionHash::AddPair(CBaseEntity *pEntity, CBaseEntity *pOther) +void CCollisionFilter::AddPair(CBaseEntity *pEntity, CBaseEntity *pOther) { if (pEntity == pOther) return; @@ -782,54 +781,54 @@ void CCollisionHash::AddPair(CBaseEntity *pEntity, CBaseEntity *pOther) pOtherTable->Set((int)pEntityTable->m_uiActivatorIndex, true); } -void CCollisionHash::RemovePair(CBaseEntity *pEntity, CBaseEntity *pOther) +void CCollisionFilter::RemovePair(CBaseEntity *pEntity, CBaseEntity *pOther) { unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); unsigned int uiOtherIndex = ExcIndexFromBaseEntity(pOther); - CollisionHashMap_t::iterator it; + CollisionFilterMap_t::iterator it; - it = m_mapHash.find(uiEntityIndex); - if (it != m_mapHash.end()) + it = m_mapFilter.find(uiEntityIndex); + if (it != m_mapFilter.end()) it->second->Set((int)uiOtherIndex, false); - it = m_mapHash.find(uiOtherIndex); - if (it != m_mapHash.end()) + it = m_mapFilter.find(uiOtherIndex); + if (it != m_mapFilter.end()) it->second->Set((int)uiEntityIndex, false); } -bool CCollisionHash::HasPair(CBaseEntity *pEntity, CBaseEntity *pOther) +bool CCollisionFilter::HasPair(CBaseEntity *pEntity, CBaseEntity *pOther) { unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); unsigned int uiOtherIndex = ExcIndexFromBaseEntity(pOther); - CollisionHashMap_t::iterator it; + CollisionFilterMap_t::iterator it; - it = m_mapHash.find(uiEntityIndex); - if (it != m_mapHash.end() && !it->second->IsBitSet((int)uiOtherIndex)) + it = m_mapFilter.find(uiEntityIndex); + if (it == m_mapFilter.end() || !it->second->IsBitSet((int)uiOtherIndex)) return false; - it = m_mapHash.find(uiOtherIndex); - if (it != m_mapHash.end() && !it->second->IsBitSet((int)uiEntityIndex)) + it = m_mapFilter.find(uiOtherIndex); + if (it == m_mapFilter.end() || !it->second->IsBitSet((int)uiEntityIndex)) return false; return true; } -void CCollisionHash::RemovePairs(CBaseEntity *pEntity) +void CCollisionFilter::RemovePairs(CBaseEntity *pEntity) { unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); - CollisionHashMap_t::iterator it = m_mapHash.find(uiEntityIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiEntityIndex); + if (it != m_mapFilter.end()) { boost::shared_ptr pEntityTable = it->second; for (unsigned int uiOtherIndex = 0; uiOtherIndex < MAX_EDICTS; ++uiOtherIndex) { if (pEntityTable->IsBitSet((int)uiOtherIndex)) { - CollisionHashMap_t::iterator it = m_mapHash.find(uiOtherIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiOtherIndex); + if (it != m_mapFilter.end()) { boost::shared_ptr pOtherTable = it->second; if (pOtherTable->IsBitSet((int)uiEntityIndex)) @@ -843,21 +842,21 @@ void CCollisionHash::RemovePairs(CBaseEntity *pEntity) } } -int CCollisionHash::CountPairs(CBaseEntity *pEntity) +int CCollisionFilter::CountPairs(CBaseEntity *pEntity) { unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); int count = 0; - CollisionHashMap_t::iterator it = m_mapHash.find(uiEntityIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiEntityIndex); + if (it != m_mapFilter.end()) { boost::shared_ptr pEntityTable = it->second; for (unsigned int uiOtherIndex = 0; uiOtherIndex < MAX_EDICTS; ++uiOtherIndex) { if (pEntityTable->IsBitSet((int)uiOtherIndex)) { - CollisionHashMap_t::iterator it = m_mapHash.find(uiOtherIndex); - if (it != m_mapHash.end() && it->second->IsBitSet((int)uiEntityIndex)) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiOtherIndex); + if (it != m_mapFilter.end() && it->second->IsBitSet((int)uiEntityIndex)) ++count; } } @@ -866,21 +865,21 @@ int CCollisionHash::CountPairs(CBaseEntity *pEntity) return count; } -list CCollisionHash::GetPairs(CBaseEntity *pEntity) +list CCollisionFilter::GetPairs(CBaseEntity *pEntity) { unsigned int uiEntityIndex = ExcIndexFromBaseEntity(pEntity); list oEntities; - CollisionHashMap_t::iterator it = m_mapHash.find(uiEntityIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiEntityIndex); + if (it != m_mapFilter.end()) { boost::shared_ptr pEntityTable = it->second; for (unsigned int uiOtherIndex = 0; uiOtherIndex < MAX_EDICTS; ++uiOtherIndex) { if (pEntityTable->IsBitSet((int)uiOtherIndex)) { - CollisionHashMap_t::iterator it = m_mapHash.find(uiOtherIndex); - if (it != m_mapHash.end()) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiOtherIndex); + if (it != m_mapFilter.end()) { boost::shared_ptr pOtherTable = it->second; if (pOtherTable->IsBitSet((int)uiEntityIndex)) @@ -895,38 +894,38 @@ list CCollisionHash::GetPairs(CBaseEntity *pEntity) return oEntities; } -void CCollisionHash::Clear() +void CCollisionFilter::Clear() { - for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + for (CollisionFilterMap_t::iterator it = m_mapFilter.begin(); it != m_mapFilter.end(); ++it) { it->second->ClearAll(); } } -inline bool CCollisionHash::IsSet(unsigned int uiActivatorIndex, unsigned int uiOtherIndex) +inline bool CCollisionFilter::IsSet(unsigned int uiActivatorIndex, unsigned int uiOtherIndex) { - CollisionHashMap_t::iterator it = m_mapHash.find(uiActivatorIndex); - if (it != m_mapHash.end() && it->second->IsBitSet((int)uiOtherIndex)) + CollisionFilterMap_t::iterator it = m_mapFilter.find(uiActivatorIndex); + if (it != m_mapFilter.end() && it->second->IsBitSet((int)uiOtherIndex)) return true; return false; } -inline void CCollisionHash::Erase(CBaseEntity *pEntity) +inline void CCollisionFilter::Erase(CBaseEntity *pEntity) { unsigned int uiIndex = ((CBaseEntityWrapper *)pEntity)->GetIndex(); - m_mapHash.erase(uiIndex); + m_mapFilter.erase(uiIndex); - for (CollisionHashMap_t::iterator it = m_mapHash.begin(); it != m_mapHash.end(); ++it) + for (CollisionFilterMap_t::iterator it = m_mapFilter.begin(); it != m_mapFilter.end(); ++it) { it->second->Set((int)uiIndex, false); } } -void CCollisionHash::UnloadInstance() +void CCollisionFilter::UnloadInstance() { static CCollisionManager *pManager = GetCollisionManager(); - pManager->UnregisterHash(this); + pManager->UnregisterFilter(this); } diff --git a/src/core/modules/entities/entities_collisions.h b/src/core/modules/entities/entities_collisions.h index a547d1bbd..de1f9a4e5 100755 --- a/src/core/modules/entities/entities_collisions.h +++ b/src/core/modules/entities/entities_collisions.h @@ -34,7 +34,6 @@ #include "sp_main.h" #include "modules/listeners/listeners_manager.h" #include "modules/entities/entities_entity.h" -#include "modules/physics/physics.h" #include "modules/memory/memory_hooks.h" // Boost @@ -42,7 +41,6 @@ #include "boost/unordered_set.hpp" // SDK -#include "vphysics/object_hash.h" #include "bitvec.h" @@ -64,7 +62,7 @@ class CCollisionCache; typedef boost::unordered_map CollisionHooksMap_t; typedef CBitVec CollisionTable_t; -typedef boost::unordered_map> CollisionHashMap_t; +typedef boost::unordered_map> CollisionFilterMap_t; typedef CBitVec CollisionCache_t; typedef boost::unordered_map CollisionCacheMap_t; @@ -134,13 +132,13 @@ class CCollisionTable : public CollisionTable_t //----------------------------------------------------------------------------- -// CCollisionHash class. +// CCollisionFilter class. //----------------------------------------------------------------------------- -class CCollisionHash +class CCollisionFilter { public: - CCollisionHash(); - ~CCollisionHash(); + CCollisionFilter(); + ~CCollisionFilter(); boost::shared_ptr GetCollisionTable(CBaseEntity *pActivator); boost::shared_ptr GetCollisionTable(unsigned int uiActivatorIndex); @@ -172,7 +170,7 @@ class CCollisionHash void UnloadInstance(); private: - CollisionHashMap_t m_mapHash; + CollisionFilterMap_t m_mapFilter; }; @@ -208,8 +206,8 @@ class CCollisionManager void Initialize(); void Finalize(); - void RegisterHash(CCollisionHash *pHash); - void UnregisterHash(CCollisionHash *pHash); + void RegisterFilter(CCollisionFilter *pFilter); + void UnregisterFilter(CCollisionFilter *pFilter); void OnNetworkedEntityCreated(object oEntity); void OnNetworkedEntityDeleted(CBaseEntity *pEntity); @@ -237,7 +235,7 @@ class CCollisionManager private: bool m_bInitialized; unsigned int m_uiRefCount; - CUtlVector m_vecHashes; + CUtlVector m_vecFilteres; CollisionHooksMap_t m_mapHooks; std::vector m_vecScopes; diff --git a/src/core/modules/entities/entities_collisions_wrap.cpp b/src/core/modules/entities/entities_collisions_wrap.cpp index 6cb18f4a2..288e04c95 100755 --- a/src/core/modules/entities/entities_collisions_wrap.cpp +++ b/src/core/modules/entities/entities_collisions_wrap.cpp @@ -37,7 +37,7 @@ //----------------------------------------------------------------------------- static void export_collision_manager(scope); static void export_collision_table(scope); -static void export_collision_hash(scope); +static void export_collision_filter(scope); //----------------------------------------------------------------------------- @@ -47,12 +47,12 @@ DECLARE_SP_SUBMODULE(_entities, _collisions) { export_collision_manager(_collisions); export_collision_table(_collisions); - export_collision_hash(_collisions); + export_collision_filter(_collisions); } //----------------------------------------------------------------------------- -// Exports ICollisionHash. +// Exports CCollisionManager. //----------------------------------------------------------------------------- void export_collision_manager(scope _collisions) { @@ -161,120 +161,120 @@ void export_collision_table(scope _collisions) //----------------------------------------------------------------------------- -// Exports CCollisionHash. +// Exports CCollisionFilter. //----------------------------------------------------------------------------- -void export_collision_hash(scope _collisions) +void export_collision_filter(scope _collisions) { - class_ CollisionHash("CollisionHash"); + class_ CollisionFilter("CollisionFilter"); // Methods... - CollisionHash.def( + CollisionFilter.def( "get_collision_table", - GET_METHOD(boost::shared_ptr, CCollisionHash, GetCollisionTable, CBaseEntity *), + GET_METHOD(boost::shared_ptr, CCollisionFilter, GetCollisionTable, CBaseEntity *), "Returns the CollisionTable for the given activator entity." ); - CollisionHash.def( + CollisionFilter.def( "disable_from", - &CCollisionHash::DisableFrom, + &CCollisionFilter::DisableFrom, "Disables collision of the given entity from the activator entity." ); - CollisionHash.def( + CollisionFilter.def( "reset_from", - &CCollisionHash::ResetFrom, + &CCollisionFilter::ResetFrom, "Resets collision of the given entity from the activator entity." ); - CollisionHash.def( + CollisionFilter.def( "is_disabled_from", - &CCollisionHash::IsDisabledFrom, + &CCollisionFilter::IsDisabledFrom, "Returns whether collision of the given entity is disabled from the activator entity." ); - CollisionHash.def( + CollisionFilter.def( "disable", - &CCollisionHash::Disable, + &CCollisionFilter::Disable, "Disables collision of the given entity in all activator entities." ); - CollisionHash.def( + CollisionFilter.def( "reset", - &CCollisionHash::Reset, + &CCollisionFilter::Reset, "Resets collision of the given entity in all activator entities." ); - CollisionHash.def( + CollisionFilter.def( "is_disabled", - &CCollisionHash::IsDisabled, + &CCollisionFilter::IsDisabled, "Returns whether collision of the given entity has been disabled for any activator entity." ); - CollisionHash.def( + CollisionFilter.def( "get_disabled_activator", - &CCollisionHash::GetDisabledActivator, + &CCollisionFilter::GetDisabledActivator, "Returns a list of activator entities with collision disabled for the given entity." ); - CollisionHash.def( + CollisionFilter.def( "add_pair", - &CCollisionHash::AddPair, - "Adds the given entity pair to the hash." + &CCollisionFilter::AddPair, + "Adds the given entity pair to the filter." ); - CollisionHash.def( + CollisionFilter.def( "remove_pair", - &CCollisionHash::RemovePair, - "Removes the given pair from the hash." + &CCollisionFilter::RemovePair, + "Removes the given pair from the filter." ); - CollisionHash.def( + CollisionFilter.def( "has_pair", - &CCollisionHash::HasPair, - "Returns whether the given pair is in the hash." + &CCollisionFilter::HasPair, + "Returns whether the given pair is in the filter." ); - CollisionHash.def( + CollisionFilter.def( "remove_pairs", - &CCollisionHash::RemovePairs, + &CCollisionFilter::RemovePairs, "Removes all pairs associated with the given entity." ); - CollisionHash.def( + CollisionFilter.def( "count_pairs", - &CCollisionHash::CountPairs, + &CCollisionFilter::CountPairs, "Returns the amount of pairs associated with the given entity." ); - CollisionHash.def( + CollisionFilter.def( "get_pairs", - &CCollisionHash::GetPairs, + &CCollisionFilter::GetPairs, "Returns a list of all entities associated with the given entity." ); - CollisionHash.def( + CollisionFilter.def( "clear", - &CCollisionHash::Clear, + &CCollisionFilter::Clear, "Resets collision across all entities in all activator entities." ); // Special methods... - CollisionHash.def( + CollisionFilter.def( "__getitem__", - GET_METHOD(boost::shared_ptr, CCollisionHash, GetCollisionTable, unsigned int), + GET_METHOD(boost::shared_ptr, CCollisionFilter, GetCollisionTable, unsigned int), "Returns the CollisionTable for the given activator entity index." ); - CollisionHash.def( + CollisionFilter.def( "__contains__", - &CCollisionHash::IsDisabled, + &CCollisionFilter::IsDisabled, "Returns whether collision of the given entity has been disabled for any activator entity." ); // AutoUnload... - CollisionHash.def( + CollisionFilter.def( "_unload_instance", - &CCollisionHash::UnloadInstance, + &CCollisionFilter::UnloadInstance, "Called when an instance is being unloaded." ); }