BVB Source Codes

CRYENGINE Show ActorLookUp.h Source code

Return Download CRYENGINE: download ActorLookUp.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __ActorLookUp_h__
  4. #define __ActorLookUp_h__
  5.  
  6. #pragma once
  7.  
  8. #include "AIActor.h"
  9.  
  10. template<typename Ty> struct ActorLookUpCastHelper
  11. {
  12.         static Ty* Cast(CAIActor* ptr) { assert(!"dangerous cast!"); return static_cast<Ty*>(ptr); }
  13. };
  14.  
  15. template<> struct ActorLookUpCastHelper<CAIObject>
  16. {
  17.         static CAIObject* Cast(CAIActor* ptr) { return static_cast<CAIObject*>(ptr); }
  18. };
  19.  
  20. template<> struct ActorLookUpCastHelper<CAIActor>
  21. {
  22.         static CAIActor* Cast(CAIActor* ptr) { return ptr; }
  23. };
  24.  
  25. template<> struct ActorLookUpCastHelper<CPipeUser>
  26. {
  27.         static CPipeUser* Cast(CAIActor* ptr) { return ptr->CastToCPipeUser(); }
  28. };
  29.  
  30. template<> struct ActorLookUpCastHelper<CPuppet>
  31. {
  32.         static CPuppet* Cast(CAIActor* ptr) { return ptr->CastToCPuppet(); }
  33. };
  34.  
  35. class ActorLookUp
  36. {
  37. public:
  38.         ILINE size_t GetActiveCount() const
  39.         {
  40.                 return m_actors.size();
  41.         }
  42.  
  43.         template<typename Ty>
  44.         ILINE Ty* GetActor(uint32 index) const
  45.         {
  46.                 if (index < m_actors.size())
  47.                 {
  48.                         if (CAIActor* actor = m_actors[index])
  49.                                 return ActorLookUpCastHelper<Ty>::Cast(actor);
  50.                 }
  51.  
  52.                 return 0;
  53.         }
  54.  
  55.         ILINE IAIActorProxy* GetProxy(uint32 index) const
  56.         {
  57.                 return m_proxies[index];
  58.         }
  59.  
  60.         ILINE const Vec3& GetPosition(uint32 index) const
  61.         {
  62.                 return m_positions[index];
  63.         }
  64.  
  65.         ILINE EntityId GetEntityID(uint32 index) const
  66.         {
  67.                 return m_entityIDs[index];
  68.         }
  69.  
  70.         ILINE void UpdatePosition(CAIActor* actor, const Vec3& position)
  71.         {
  72.                 size_t activeActorCount = GetActiveCount();
  73.  
  74.                 for (size_t i = 0; i < activeActorCount; ++i)
  75.                 {
  76.                         if (m_actors[i] == actor)
  77.                         {
  78.                                 m_positions[i] = position;
  79.                                 return;
  80.                         }
  81.                 }
  82.         }
  83.  
  84.         ILINE void UpdateProxy(CAIActor* actor)
  85.         {
  86.                 size_t activeActorCount = GetActiveCount();
  87.  
  88.                 for (size_t i = 0; i < activeActorCount; ++i)
  89.                 {
  90.                         if (m_actors[i] == actor)
  91.                         {
  92.                                 m_proxies[i] = actor->GetProxy();
  93.                                 return;
  94.                         }
  95.                 }
  96.         }
  97.  
  98.         enum
  99.         {
  100.                 Proxy    = BIT(0),
  101.                 Position = BIT(1),
  102.                 EntityID = BIT(2),
  103.         };
  104.  
  105.         ILINE void Prepare(uint32 lookUpFields)
  106.         {
  107.                 if (!m_actors.empty())
  108.                 {
  109.                         CryPrefetch(&m_actors[0]);
  110.  
  111.                         if (lookUpFields & Proxy)
  112.                         {
  113.                                 CryPrefetch(&m_proxies[0]);
  114.                         }
  115.  
  116.                         if (lookUpFields & Position)
  117.                         {
  118.                                 CryPrefetch(&m_positions[0]);
  119.                         }
  120.  
  121.                         if (lookUpFields & EntityID)
  122.                         {
  123.                                 CryPrefetch(&m_entityIDs[0]);
  124.                         }
  125.                 }
  126.         }
  127.  
  128.         void AddActor(CAIActor* actor)
  129.         {
  130.                 assert(actor);
  131.  
  132.                 size_t activeActorCount = GetActiveCount();
  133.  
  134.                 for (uint32 i = 0; i < activeActorCount; ++i)
  135.                 {
  136.                         if (m_actors[i] == actor)
  137.                         {
  138.                                 m_proxies[i] = actor->GetProxy();
  139.                                 m_positions[i] = actor->GetPos();
  140.                                 m_entityIDs[i] = actor->GetEntityID();
  141.  
  142.                                 return;
  143.                         }
  144.                 }
  145.  
  146.                 m_actors.push_back(actor);
  147.                 m_proxies.push_back(actor->GetProxy());
  148.                 m_positions.push_back(actor->GetPos());
  149.                 m_entityIDs.push_back(actor->GetEntityID());
  150.         }
  151.  
  152.         void RemoveActor(CAIActor* actor)
  153.         {
  154.                 assert(actor);
  155.  
  156.                 size_t activeActorCount = GetActiveCount();
  157.  
  158.                 for (size_t i = 0; i < activeActorCount; ++i)
  159.                 {
  160.                         if (m_actors[i] == actor)
  161.                         {
  162.                                 std::swap(m_actors[i], m_actors.back());
  163.                                 m_actors.pop_back();
  164.  
  165.                                 std::swap(m_proxies[i], m_proxies.back());
  166.                                 m_proxies.pop_back();
  167.  
  168.                                 std::swap(m_positions[i], m_positions.back());
  169.                                 m_positions.pop_back();
  170.  
  171.                                 std::swap(m_entityIDs[i], m_entityIDs.back());
  172.                                 m_entityIDs.pop_back();
  173.  
  174.                                 return;
  175.                         }
  176.                 }
  177.         }
  178.  
  179. private:
  180.         typedef std::vector<CAIActor*> Actors;
  181.         Actors m_actors;
  182.  
  183.         typedef std::vector<IAIActorProxy*> Proxies;
  184.         Proxies m_proxies;
  185.  
  186.         typedef std::vector<Vec3> Positions;
  187.         Positions m_positions;
  188.  
  189.         typedef std::vector<EntityId> EntityIDs;
  190.         EntityIDs m_entityIDs;
  191. };
  192.  
  193. #endif
  194.  
downloadActorLookUp.h 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