Added caching.

Author: jordanbriere

src/core/modules/entities/entities_collisions.cpp

@@ -41,14 +41,16 @@
 //-----------------------------------------------------------------------------
 extern IEngineTrace *enginetrace;
 extern IPhysics *physics;
+extern CGlobalVars *gpGlobals;
 
 
 //-----------------------------------------------------------------------------
 // CCollisionManager class.
 //-----------------------------------------------------------------------------
 CCollisionManager::CCollisionManager():
 	m_bInitialized(false),
-	m_uiRefCount(0)
+	m_uiRefCount(0),
+	m_nTickCount(-1)
 {
 
 }
@@ -206,6 +208,7 @@ void CCollisionManager::RegisterHook(T tFunc, unsigned int uiFilterIndex, unsign
 bool CCollisionManager::EnterScope(HookType_t eHookType, CHook *pHook)
 {
 	static CCollisionManager *pManager = GetCollisionManager();
+	pManager->RefreshCache();
 
 	CollisionScope_t scope;
 	scope.m_bSkip = true;
@@ -288,6 +291,7 @@ bool CCollisionManager::EnterScope(HookType_t eHookType, CHook *pHook)
 
 	scope.m_pFilter = pWrapper;
 	scope.m_uiIndex = uiIndex;
+	scope.m_pCache = pManager->GetCache(uiIndex);
 	scope.m_pExtraShouldHitCheckFunction = pWrapper->m_pExtraShouldHitCheckFunction;
 	pWrapper->m_pExtraShouldHitCheckFunction = (ShouldHitFunc_t)CCollisionManager::ShouldHitEntity;
 
@@ -349,14 +353,20 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten
 		}
 	}
 
+	if (scope.m_pCache->HasResult(uiIndex)) {
+		return scope.m_pCache->GetResult(uiIndex);
+	}
+
 	FOR_EACH_VEC(pManager->m_vecHashes, i) {
 		if (pManager->m_vecHashes[i]->HasPair((void *)scope.m_pFilter->m_pPassEnt, (void *)pHandleEntity)) {
+			scope.m_pCache->SetResult(uiIndex, false);
 			return false;
 		}
 	}
 
 	static CEntityCollisionListenerManager *pListener = GetOnEntityCollisionListenerManager();
 	if (!pListener->GetCount()) {
+		scope.m_pCache->SetResult(uiIndex, true);
 		return true;
 	}
 
@@ -369,14 +379,43 @@ bool CCollisionManager::ShouldHitEntity(IHandleEntity *pHandleEntity, int conten
 		BEGIN_BOOST_PY()
 			object oResult = pListener->m_vecCallables[i](oEntity, oOther);
 			if (!oResult.is_none() && !extract<bool>(oResult)) {
+				scope.m_pCache->SetResult(uiIndex, false);
 				return false;
 			}
 		END_BOOST_PY_NORET()
 	}
 
+	scope.m_pCache->SetResult(uiIndex, true);
 	return true;
 }
 
+void CCollisionManager::RefreshCache()
+{
+	if (gpGlobals->tickcount == m_nTickCount) {
+		return;
+	}
+
+	for (CollisionCacheMap_t::const_iterator it = m_mapCache.begin(); it != m_mapCache.end(); it++) {
+		delete it->second;
+	}
+
+	m_mapCache.clear();
+	m_nTickCount = gpGlobals->tickcount;
+}
+
+CCollisionCache *CCollisionManager::GetCache(unsigned int uiIndex)
+{
+	CollisionCacheMap_t::const_iterator it = m_mapCache.find(uiIndex);
+	if (it != m_mapCache.end()) {
+		return it->second;
+	}
+
+	CCollisionCache *pCache = new CCollisionCache();
+	m_mapCache[uiIndex] = pCache;
+
+	return pCache;
+}
+
 
 //-----------------------------------------------------------------------------
 // ICollisionHash class.
@@ -399,6 +438,26 @@ void ICollisionHash::UnloadInstance()
 }
 
 
+//-----------------------------------------------------------------------------
+// CCollisionCache class.
+//-----------------------------------------------------------------------------
+bool CCollisionCache::HasResult(unsigned int uiIndex)
+{
+	return IsBitSet(uiIndex);
+}
+
+bool CCollisionCache::GetResult(unsigned int uiIndex)
+{
+	return m_vecCache.IsBitSet(uiIndex);
+}
+
+void CCollisionCache::SetResult(unsigned int uiIndex, bool bResult)
+{
+	Set(uiIndex);
+	m_vecCache.Set((int)uiIndex, bResult);
+}
+
+
 //-----------------------------------------------------------------------------
 // CCollisionHash class.
 //-----------------------------------------------------------------------------

src/core/modules/entities/entities_collisions.h

@@ -41,12 +41,14 @@
 
 // SDK
 #include "vphysics/object_hash.h"
+#include "bitvec.h"
 
 
 //-----------------------------------------------------------------------------
 // Forward declarations.
 //-----------------------------------------------------------------------------
 struct CollisionHookData_t;
+class CCollisionCache;
 
 
 //-----------------------------------------------------------------------------
@@ -58,6 +60,9 @@ struct CollisionHookData_t;
 
 typedef boost::unordered_map<CHook *, CollisionHookData_t> CollisionHooksMap_t;
 
+typedef CBitVec<MAX_EDICTS> CollisionCache_t;
+typedef boost::unordered_map<unsigned int, CCollisionCache *> CollisionCacheMap_t;
+
 
 //-----------------------------------------------------------------------------
 // CTraceFilterSimpleWrapper class.
@@ -80,6 +85,7 @@ struct CollisionScope_t
 	unsigned int m_uiIndex;
 	CTraceFilterSimpleWrapper *m_pFilter;
 	ShouldHitFunc_t m_pExtraShouldHitCheckFunction;
+	CCollisionCache *m_pCache;
 };
 
 
@@ -140,6 +146,21 @@ class CCollisionHash : public ICollisionHash
 };
 
 
+//-----------------------------------------------------------------------------
+// CCollisionCache class.
+//-----------------------------------------------------------------------------
+class CCollisionCache : private CollisionCache_t
+{
+public:
+	bool HasResult(unsigned int uiIndex);
+	bool GetResult(unsigned int uiIndex);
+	void SetResult(unsigned int uiIndex, bool bResult);
+
+private:
+	CollisionCache_t m_vecCache;
+};
+
+
 //-----------------------------------------------------------------------------
 // CCollisionManager class.
 //-----------------------------------------------------------------------------
@@ -172,12 +193,18 @@ class CCollisionManager
 
 	static bool ShouldHitEntity(IHandleEntity *pHandleEntity, int contentsMask);
 
+	void RefreshCache();
+	CCollisionCache *GetCache(unsigned int uiIndex);
+
 private:
 	bool m_bInitialized;
 	unsigned int m_uiRefCount;
 	CUtlVector<ICollisionHash *> m_vecHashes;
 	CollisionHooksMap_t m_mapHooks;
 	std::vector<CollisionScope_t> m_vecScopes;
+
+	int m_nTickCount;
+	CollisionCacheMap_t m_mapCache;
 };
 
 // Singleton accessor.