BVB Source Codes

CRYENGINE Show WalkabilityCacheManager.cpp Source code

Return Download CRYENGINE: download WalkabilityCacheManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "WalkabilityCacheManager.h"
  5. #include "ObjectContainer.h"
  6. #include "DebugDrawContext.h"
  7.  
  8. WalkabilityCacheManager::WalkabilityCacheManager()
  9.         : m_currentFrameID(0)
  10.         , m_walkabilityRequestCount(0)
  11.         , m_walkabilityCacheHitCount(0)
  12.         , m_floorRequestCount(0)
  13.         , m_floorCacheHitCount(0)
  14.         , m_preservedFloorCache(0)
  15. {
  16. }
  17.  
  18. WalkabilityCacheManager::~WalkabilityCacheManager()
  19. {
  20.         Reset();
  21. }
  22.  
  23. void WalkabilityCacheManager::Reset()
  24. {
  25.         while (!m_caches.empty())
  26.                 EnableActor(m_caches.begin()->first, false);
  27.  
  28.         m_alloc.FreeMemory();
  29.  
  30.         m_walkabilityRequestCount = 0;
  31.         m_walkabilityCacheHitCount = 0;
  32.         m_floorRequestCount = 0;
  33.         m_floorCacheHitCount = 0;
  34.         m_preservedFloorCache = 0;
  35. }
  36.  
  37. void WalkabilityCacheManager::PreUpdate()
  38. {
  39.         m_currentFrameID = gEnv->nMainFrameID;
  40.  
  41.         m_walkabilityRequestCount = 0;
  42.         m_walkabilityCacheHitCount = 0;
  43.         m_floorRequestCount = 0;
  44.         m_floorCacheHitCount = 0;
  45.         m_preservedFloorCache = 0;
  46. }
  47.  
  48. void WalkabilityCacheManager::PostUpdate()
  49. {
  50. }
  51.  
  52. void WalkabilityCacheManager::Draw()
  53. {
  54.         ActorWalkabilityCaches::iterator it = m_caches.begin();
  55.         ActorWalkabilityCaches::iterator end = m_caches.end();
  56.  
  57.         size_t memoryUsage = 0;
  58.  
  59.         for (; it != end; ++it)
  60.         {
  61.                 ActorWalkabilityCache& actorCache = it->second;
  62.                 actorCache.cache->Draw();
  63.  
  64.                 memoryUsage += actorCache.cache->GetMemoryUsage();
  65.         }
  66.  
  67.         memoryUsage += m_alloc.GetTotalMemory().nAlloc;
  68.  
  69.         const float startY = 380.0f;
  70.         float x = 1024.0f - 10.0f - 175.0f;
  71.         float y = startY;
  72.  
  73.         CDebugDrawContext dc;
  74.         const float FontSize = 1.2f;
  75.         const float LineHeight = 11.25f * FontSize;
  76.  
  77.         dc->Draw2dLabel(x, y, FontSize * 1.25f, Col_BlueViolet, false, "WalkabilityCheck Stats");
  78.         y += LineHeight * 1.25f;
  79.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Actors: %" PRISIZE_T, m_caches.size());
  80.         y += LineHeight;
  81.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Memory: %.2fK", memoryUsage / 1024.0f);
  82.         y += LineHeight;
  83.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Requested: %" PRISIZE_T, m_walkabilityRequestCount);
  84.         y += LineHeight;
  85.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Hit Cache: %" PRISIZE_T " (%.1f%%)",
  86.                         m_walkabilityCacheHitCount,
  87.                         m_walkabilityRequestCount ? (m_walkabilityCacheHitCount / (float)m_walkabilityRequestCount) * 100.0f : 0.0f);
  88.         y += LineHeight;
  89.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Preserved Floor Caches: %" PRISIZE_T, m_preservedFloorCache);
  90.         y += LineHeight;
  91.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Floor Checks: %" PRISIZE_T, m_floorRequestCount);
  92.         y += LineHeight;
  93.         dc->Draw2dLabel(x, y, FontSize, Col_BlueViolet, false, "Floor Hit Cache: %" PRISIZE_T " (%.1f%%)",
  94.                         m_floorCacheHitCount,
  95.                         m_floorRequestCount ? (m_floorCacheHitCount / (float)m_floorRequestCount) * 100.0f : 0.0f);
  96.         y += LineHeight;
  97. }
  98.  
  99. void WalkabilityCacheManager::EnableActor(tAIObjectID actorID, bool enabled)
  100. {
  101.         if (!enabled)
  102.         {
  103.                 ActorWalkabilityCaches::iterator it = m_caches.find(actorID);
  104.                 if (it != m_caches.end())
  105.                 {
  106.                         ActorWalkabilityCache& actorCache = it->second;
  107.                         if (actorCache.cache)
  108.                         {
  109.                                 actorCache.cache->~WalkabilityCache();
  110.                                 m_alloc.Deallocate(actorCache.cache);
  111.                         }
  112.  
  113.                         m_caches.erase(it);
  114.                 }
  115.         }
  116. }
  117.  
  118. void WalkabilityCacheManager::PrepareActor(tAIObjectID actorID, const AABB& aabb)
  119. {
  120.         ActorWalkabilityCaches::iterator it = m_caches.find(actorID);
  121.         if (it == m_caches.end())
  122.         {
  123.                 std::pair<ActorWalkabilityCaches::iterator, bool> iresult =
  124.                   m_caches.insert(ActorWalkabilityCaches::value_type(actorID, ActorWalkabilityCache()));
  125.  
  126.                 it = iresult.first;
  127.         }
  128.  
  129.         if (it != m_caches.end())
  130.         {
  131.                 ActorWalkabilityCache& actorCache = it->second;
  132.                 if (!actorCache.cache)
  133.                         actorCache.cache = new(m_alloc.Allocate())WalkabilityCache(actorID);
  134.  
  135.                 if (m_currentFrameID != actorCache.frameID)
  136.                 {
  137.                         IAIObject* actorObject = gAIEnv.pObjectContainer->GetAIObject(it->first);
  138.                         assert(actorObject);
  139.                         if (actorObject)
  140.                         {
  141.                                 if (!actorCache.cache->Cache(aabb))
  142.                                         ++m_preservedFloorCache;
  143.                         }
  144.  
  145.                         actorCache.frameID = m_currentFrameID;
  146.                 }
  147.         }
  148. }
  149.  
  150. bool WalkabilityCacheManager::IsFloorCached(tAIObjectID actorID, const Vec3& position, Vec3& floor)
  151. {
  152.         ++m_floorRequestCount;
  153.  
  154.         if (!m_caches.empty())
  155.         {
  156.                 ActorWalkabilityCaches::iterator it = m_caches.find(actorID);
  157.                 ActorWalkabilityCaches::iterator end = m_caches.end();
  158.  
  159.                 if (it != end)
  160.                 {
  161.                         ActorWalkabilityCache& actorCache = it->second;
  162.  
  163.                         if (actorCache.frameID == m_currentFrameID)
  164.                         {
  165.                                 if (actorCache.cache->IsFloorCached(position, floor))
  166.                                 {
  167.                                         ++m_floorCacheHitCount;
  168.  
  169.                                         return true;
  170.                                 }
  171.                         }
  172.                 }
  173.  
  174.                 // check other actors' aabbs
  175.                 it = m_caches.begin();
  176.  
  177.                 for (; it != end; ++it)
  178.                 {
  179.                         ActorWalkabilityCache& actorCache = it->second;
  180.  
  181.                         if ((actorCache.frameID == m_currentFrameID) && (it->first != actorID))
  182.                         {
  183.                                 if (actorCache.cache->IsFloorCached(position, floor))
  184.                                 {
  185.                                         ++m_floorCacheHitCount;
  186.  
  187.                                         return true;
  188.                                 }
  189.                         }
  190.                 }
  191.         }
  192.  
  193.         return false;
  194. }
  195.  
  196. bool WalkabilityCacheManager::FindFloor(tAIObjectID actorID, const Vec3& position, Vec3& floor)
  197. {
  198.         ++m_floorRequestCount;
  199.  
  200.         if (!m_caches.empty())
  201.         {
  202.                 ActorWalkabilityCaches::iterator it = m_caches.find(actorID);
  203.                 ActorWalkabilityCaches::iterator end = m_caches.end();
  204.  
  205.                 if (it != end)
  206.                 {
  207.                         ActorWalkabilityCache& actorCache = it->second;
  208.  
  209.                         if (actorCache.frameID == m_currentFrameID)
  210.                         {
  211.                                 if (actorCache.cache->IsFloorCached(position, floor))
  212.                                 {
  213.                                         ++m_floorCacheHitCount;
  214.  
  215.                                         return floor.z < FLT_MAX;
  216.                                 }
  217.                         }
  218.                 }
  219.  
  220.                 // check other actors' aabbs
  221.                 it = m_caches.begin();
  222.  
  223.                 for (; it != end; ++it)
  224.                 {
  225.                         ActorWalkabilityCache& actorCache = it->second;
  226.  
  227.                         if ((actorCache.frameID == m_currentFrameID) && (it->first != actorID))
  228.                         {
  229.                                 if (actorCache.cache->IsFloorCached(position, floor))
  230.                                 {
  231.                                         ++m_floorCacheHitCount;
  232.  
  233.                                         return floor.z < FLT_MAX;
  234.                                 }
  235.                         }
  236.                 }
  237.         }
  238.  
  239.         // TODO: Keep track of the best containing cache and perform the floor search in there, so it's stored in the cache and
  240.         // uses the already filtered physical entities
  241.  
  242.         return ::FindFloor(position, floor);
  243. }
  244.  
  245. bool WalkabilityCacheManager::CheckWalkability(tAIObjectID actorID, const Vec3& origin, const Vec3& target, float radius,
  246.                                                Vec3* finalFloor, bool* flatFloor)
  247. {
  248.         ++m_walkabilityRequestCount;
  249.  
  250.         if (!m_caches.empty())
  251.         {
  252.                 float minZ = min(origin.z, target.z) - WalkabilityFloorDownDist;
  253.                 float maxZ = max(origin.z, target.z) + WalkabilityTotalHeight;
  254.  
  255.                 AABB enclosingAABB(AABB::RESET);
  256.                 enclosingAABB.Add(Vec3(origin.x, origin.y, minZ), radius);
  257.                 enclosingAABB.Add(Vec3(target.x, target.y, maxZ), radius);
  258.  
  259.                 ActorWalkabilityCaches::iterator it = m_caches.find(actorID);
  260.                 ActorWalkabilityCaches::iterator end = m_caches.end();
  261.  
  262.                 if (it != end)
  263.                 {
  264.                         ActorWalkabilityCache& actorCache = it->second;
  265.  
  266.                         if (actorCache.frameID == m_currentFrameID)
  267.                         {
  268.                                 if (actorCache.cache->FullyContaints(enclosingAABB))
  269.                                 {
  270.                                         ++m_walkabilityCacheHitCount;
  271.                                         return actorCache.cache->CheckWalkability(origin, target, radius, finalFloor, flatFloor);
  272.                                 }
  273.                         }
  274.                 }
  275.  
  276.                 // check other actors' aabbs
  277.                 it = m_caches.begin();
  278.  
  279.                 for (; it != end; ++it)
  280.                 {
  281.                         ActorWalkabilityCache& actorCache = it->second;
  282.  
  283.                         if ((actorCache.frameID == m_currentFrameID) && (it->first != actorID))
  284.                         {
  285.                                 if (actorCache.cache->FullyContaints(enclosingAABB))
  286.                                 {
  287.                                         ++m_walkabilityCacheHitCount;
  288.                                         return actorCache.cache->CheckWalkability(origin, target, radius, finalFloor, flatFloor);
  289.                                 }
  290.                         }
  291.                 }
  292.         }
  293.  
  294.         // need to add floor flatness computation
  295.         return ::CheckWalkability(origin, target, radius, finalFloor, flatFloor);
  296. }
  297.  
  298. bool WalkabilityCacheManager::CheckWalkability(tAIObjectID actorID, const Vec3& origin, const Vec3& target, float radius,
  299.                                                const ListPositions& boundary, Vec3* finalFloor, bool* flatFloor,
  300.                                                const AABB* boundaryAABB)
  301. {
  302.         if (Overlap::Lineseg_Polygon2D(Lineseg(origin, target), boundary, boundaryAABB))
  303.                 return false;
  304.  
  305.         return CheckWalkability(actorID, origin, target, radius, finalFloor, flatFloor);
  306. }
  307.  
downloadWalkabilityCacheManager.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top