BVB Source Codes

CRYENGINE Show PerceptionManager.h Source code

Return Download CRYENGINE: download PerceptionManager.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   PerceptionManager.h
  6.    $Id$
  7.    Description:
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 2008                               : Created by Mikko Mononen
  12.    - 2 Mar 2009 : Evgeny Adamenkov: Removed IRenderer
  13.  
  14.  *********************************************************************/
  15.  
  16. #ifndef _PERCEPTIONMANAGER_H_
  17. #define _PERCEPTIONMANAGER_H_
  18.  
  19. #if _MSC_VER > 1000
  20.         #pragma once
  21. #endif
  22.  
  23. #include "ValueHistory.h"
  24.  
  25. struct SAIStimulusFilter
  26. {
  27.         inline void Set(unsigned char t, unsigned char st, EAIStimulusFilterMerge m, float s)
  28.         {
  29.                 scale = s;
  30.                 merge = m;
  31.                 type = t;
  32.                 subType = st;
  33.         }
  34.  
  35.         inline void Reset()
  36.         {
  37.                 scale = 0.0f;
  38.                 merge = 0;
  39.                 type = 0;
  40.                 subType = 0;
  41.         }
  42.  
  43.         float         scale;      // How much the existing stimulus radius is scaled before checking.
  44.         unsigned char merge;      // Filter merge type, see EAIStimulusFilterMerge.
  45.         unsigned char type;       // Stimulus type to match against.
  46.         unsigned char subType;    // Stimulus subtype _mask_ to match against, or 0 if not applied.
  47. };
  48.  
  49. // Stimulus descriptor.
  50. // Defines a stimulus type and how the incoming stimuli of the specified type should be handled.
  51. //
  52. // Common stimuli defined in EAIStimulusType are already registered in the perception manager.
  53. // For game specific stimuli, the first stim type should be LAST_AISTIM.
  54. //
  55. // Example:
  56. //              desc.Reset();
  57. //              desc.SetName("Collision");
  58. //              desc.processDelay = 0.15f;
  59. //              desc.duration[AICOL_SMALL] = 7.0f;
  60. //              desc.duration[AICOL_MEDIUM] = 7.0f;
  61. //              desc.duration[AICOL_LARGE] = 7.0f;
  62. //              desc.filterTypes = (1<<AISTIM_COLLISION) | (1<<AISTIM_EXPLOSION);
  63. //              desc.nFilters = 2;
  64. //              desc.filters[0].Set(AISTIM_COLLISION, 0, AISTIMFILTER_MERGE_AND_DISCARD, 0.9f); // Merge nearby collisions
  65. //              desc.filters[1].Set(AISTIM_EXPLOSION, 0, AISTIMFILTER_DISCARD, 2.5f); // Discard collision near explosions
  66. //              pPerceptionMgr->RegisterStimulusDesc(AISTIM_COLLISION, desc);
  67. //
  68. struct SAIStimulusTypeDesc
  69. {
  70.         inline void SetName(const char* n)
  71.         {
  72.                 assert(strlen(n) < sizeof(name));
  73.                 cry_strcpy(name, n);
  74.         }
  75.  
  76.         inline void Reset()
  77.         {
  78.                 processDelay = 0.0f;
  79.                 filterTypes = 0;
  80.                 for (int i = 0; i < AI_MAX_SUBTYPES; i++)
  81.                         duration[i] = 0.0f;
  82.                 for (int i = 0; i < AI_MAX_FILTERS; i++)
  83.                         filters[i].Reset();
  84.                 name[0] = '\0';
  85.                 nFilters = 0;
  86.         }
  87.  
  88.         float             processDelay;              // Delay before the stimulus is actually sent.
  89.         unsigned int      filterTypes;               // Mask of all types of filters contained in the filter list.
  90.         float             duration[AI_MAX_SUBTYPES]; // Duration of the stimulus, accessed by the subType of SAIStimulus.
  91.         SAIStimulusFilter filters[AI_MAX_FILTERS];   // The filter list.
  92.         char              name[32];                  // Name of the stimulus.
  93.         unsigned char     nFilters;                  // Number of filters in the filter list.
  94. };
  95.  
  96. class CPerceptionManager
  97. {
  98. public:
  99.         CPerceptionManager();
  100.         ~CPerceptionManager();
  101.  
  102.         void Reset(IAISystem::EResetReason reason);
  103.         void Update(float dt);
  104.         void DebugDraw(int mode);
  105.         void DebugDrawPerformance(int mode);
  106.         void Serialize(TSerialize ser);
  107.  
  108.         bool UpdatePerception(CAIActor* pAIActor, std::vector<CAIObject*>& priorityTargets);
  109.  
  110.         void RegisterStimulus(const SAIStimulus& stim);
  111.         void IgnoreStimulusFrom(EntityId sourceId, EAIStimulusType type, float time);
  112.         bool IsPointInRadiusOfStimulus(EAIStimulusType type, const Vec3& pos) const;
  113.  
  114.         bool RegisterStimulusDesc(EAIStimulusType type, const SAIStimulusTypeDesc& desc);
  115.  
  116.         void RegisterAIEventListener(IAIEventListener* pListener, const Vec3& pos, float rad, int flags);
  117.         void UnregisterAIEventListener(IAIEventListener* pListener);
  118.  
  119. private:
  120.         struct SStimulusRecord
  121.         {
  122.                 EntityId      sourceId;
  123.                 EntityId      targetId;
  124.                 Vec3          pos;
  125.                 Vec3          dir;
  126.                 float         radius;
  127.                 float         t;
  128.                 unsigned char type;
  129.                 unsigned char subType;
  130.                 unsigned char flags;
  131.                 unsigned char dispatched;
  132.  
  133.                 void          Serialize(TSerialize ser)
  134.                 {
  135.                         ser.BeginGroup("Stim");
  136.                         ser.Value("sourceId", sourceId);
  137.                         ser.Value("targetId", targetId);
  138.                         ser.Value("pos", pos);
  139.                         ser.Value("dir", dir);
  140.                         ser.Value("radius", radius);
  141.                         ser.Value("t", t);
  142.                         ser.Value("type", type);
  143.                         ser.Value("subType", subType);
  144.                         ser.Value("flags", flags);
  145.                         ser.Value("dispatched", dispatched);
  146.                         ser.EndGroup();
  147.                 }
  148.         };
  149.  
  150.         struct SAIEventListener
  151.         {
  152.                 IAIEventListener* pListener;
  153.                 Vec3              pos;
  154.                 float             radius;
  155.                 int               flags;
  156.         };
  157.  
  158.         void  HandleSound(const SStimulusRecord& stim);
  159.         void  HandleCollision(const SStimulusRecord& stim);
  160.         void  HandleExplosion(const SStimulusRecord& stim);
  161.         void  HandleBulletHit(const SStimulusRecord& stim);
  162.         void  HandleBulletWhizz(const SStimulusRecord& stim);
  163.         void  HandleGrenade(const SStimulusRecord& stim);
  164.         void  VisCheckBroadPhase(float dt);
  165.         /// Checks if the sound is occluded.
  166.         bool  IsSoundOccluded(CAIActor* pAIActor, const Vec3& vSoundPos);
  167.         /// Suppresses the sound radius based on sound suppressors.
  168.         float SupressSound(const Vec3& pos, float radius);
  169.         int   RayOcclusionPlaneIntersection(const Vec3& start, const Vec3& end);
  170.         void  NotifyAIEventListeners(const SStimulusRecord& stim, float threat);
  171.         void  InitCommonTypeDescs();
  172.         bool  FilterStimulus(SAIStimulus* stim);
  173.  
  174.         /// Records a stimulus event to the AI recorder
  175.         void RecordStimulusEvent(const SStimulusRecord& stim, float fRadius, IAIObject& receiver) const;
  176.         void SetLastExplosionPosition(const Vec3& position, CAIActor* pAIActor) const;
  177.  
  178.         // We currently consider a stimulus visible if it's inbetween 160 degrees
  179.         // left or right of the view direction (Similar to the grenades check)
  180.         // and if the raycast to the stimulus position is successful
  181.         bool IsStimulusVisible(const SStimulusRecord& stim, const CAIActor* pAIActor);
  182.  
  183.         SAIStimulusTypeDesc             m_stimulusTypes[AI_MAX_STIMULI];
  184.         std::vector<SStimulusRecord>    m_stimuli[AI_MAX_STIMULI];
  185.         std::vector<SAIStimulus>        m_incomingStimuli;
  186.         typedef std::map<EntityId, float> StimulusIgnoreMap;
  187.         StimulusIgnoreMap               m_ignoreStimuliFrom[AI_MAX_STIMULI];
  188.         std::vector<SAIEventListener>   m_eventListeners;
  189.         float                           m_visBroadPhaseDt;
  190.  
  191.         static std::vector<CAIObject*>  s_targetEntities;
  192.         static std::vector<CAIVehicle*> s_playerVehicles;
  193.  
  194.         static const int                PERF_TRACKER_SAMPLE_COUNT = 200;
  195.  
  196.         class CPerfTracker
  197.         {
  198.                 int                m_count, m_countMax;
  199.                 CValueHistory<int> m_hist;
  200.         public:
  201.                 inline CPerfTracker() : m_count(0), m_countMax(0), m_hist(PERF_TRACKER_SAMPLE_COUNT, 0) {}
  202.                 inline ~CPerfTracker() {}
  203.  
  204.                 inline void Inc(int n = 1)
  205.                 {
  206.                         m_count += n;
  207.                 }
  208.  
  209.                 inline void Update()
  210.                 {
  211.                         m_countMax = max(m_count, m_countMax);
  212.                         m_hist.Sample(m_count);
  213.                         m_count = 0;
  214.                 }
  215.  
  216.                 inline void Reset()
  217.                 {
  218.                         m_count = m_countMax = 0;
  219.                         m_hist.Reset();
  220.                 }
  221.  
  222.                 inline int                       GetCount() const    { return m_count; }
  223.                 inline int                       GetCountMax() const { return m_countMax; }
  224.                 inline const CValueHistory<int>& GetHist() const     { return m_hist; }
  225.         };
  226.  
  227.         enum Trackers
  228.         {
  229.                 PERFTRACK_VIS_CHECKS,
  230.                 PERFTRACK_UPDATES,
  231.                 PERFTRACK_INCOMING_STIMS,
  232.                 PERFTRACK_STIMS,
  233.                 COUNT_PERFTRACK // must be last
  234.         };
  235.  
  236.         struct PerfStats
  237.         {
  238.                 inline void Update()
  239.                 {
  240.                         for (unsigned i = 0; i < COUNT_PERFTRACK; ++i)
  241.                                 trackers[i].Update();
  242.                 }
  243.  
  244.                 CPerfTracker trackers[COUNT_PERFTRACK];
  245.         };
  246.  
  247.         PerfStats m_stats;
  248. };
  249.  
  250. #endif
  251.  
downloadPerceptionManager.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