BVB Source Codes

CRYENGINE Show PostureManager.h Source code

Return Download CRYENGINE: download PostureManager.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __PostureManager_h__
  4. #define __PostureManager_h__
  5.  
  6. #if _MSC_VER > 1000
  7.         #pragma once
  8. #endif // _MSC_VER > 1000
  9.  
  10. #include "Cover/Cover.h"
  11.  
  12. class PostureManager
  13. {
  14. public:
  15.         typedef int32  PostureID;
  16.         typedef uint32 PostureQueryID;
  17.  
  18.         enum PostureType
  19.         {
  20.                 InvalidPosture = 0,
  21.                 PeekPosture    = 1,
  22.                 AimPosture     = 2,
  23.                 HidePosture    = 3,
  24.         };
  25.  
  26.         enum PostureQueryChecks
  27.         {
  28.                 CheckVisibility   = 1 << 0,
  29.                 CheckAimability   = 1 << 1,
  30.                 CheckLeanability  = 1 << 2,
  31.                 CheckFriendlyFire = 1 << 3,
  32.                 DefaultChecks     = CheckVisibility | CheckAimability | CheckLeanability | CheckFriendlyFire,
  33.         };
  34.  
  35.         struct PostureQuery
  36.         {
  37.                 PostureQuery()
  38.                         : position(ZERO)
  39.                         , target(ZERO)
  40.                         , actor(0)
  41.                         , distancePercent(0.5f)
  42.                         , coverID()
  43.                         , checks(DefaultChecks)
  44.                         , hintPostureID(-1)
  45.                         , type(InvalidPosture)
  46.                         , allowLean(true)
  47.                         , allowProne(false)
  48.                         , stickyStance(true)
  49.                 {
  50.                 }
  51.  
  52.                 Vec3        position;
  53.                 Vec3        target;
  54.  
  55.                 CAIActor*   actor;
  56.  
  57.                 float       distancePercent; // distance from actor to target to use for checks
  58.                 CoverID     coverID;         // currenct actor cover
  59.  
  60.                 uint32      checks;        // which checks to perform
  61.                 PostureID   hintPostureID; // current posture - check this first
  62.                 PostureType type;
  63.                 bool        allowLean;
  64.                 bool        allowProne;
  65.                 bool        stickyStance;
  66.         };
  67.  
  68.         struct PostureInfo
  69.         {
  70.                 PostureInfo()
  71.                         : type(InvalidPosture)
  72.                         , lean(0.0f)
  73.                         , peekOver(0.0f)
  74.                         , stance(STANCE_NULL)
  75.                         , priority(0.0f)
  76.                         , minDistanceToTarget(0.0f)
  77.                         , maxDistanceToTarget(FLT_MAX)
  78.                         , parentID(-1)
  79.                         , enabled(true)
  80.                 {}
  81.  
  82.                 PostureInfo(PostureType _type, const char* _name, float _lean, float _peekOver, EStance _stance, float _priority, const char* _agInput = "", PostureID _parentID = -1)
  83.                         : type(_type)
  84.                         , lean(_lean)
  85.                         , peekOver(_peekOver)
  86.                         , stance(_stance)
  87.                         , priority(_priority)
  88.                         , minDistanceToTarget(0.0f)
  89.                         , maxDistanceToTarget(FLT_MAX)
  90.                         , parentID(_parentID)
  91.                         , enabled(true)
  92.                         , agInput(_agInput)
  93.                         , name(_name)
  94.                 {
  95.                 }
  96.  
  97.                 void GetMemoryUsage(ICrySizer* pSizer) const
  98.                 {
  99.                         pSizer->AddObject(agInput);
  100.                         pSizer->AddObject(name);
  101.                 }
  102.  
  103.                 PostureType type;
  104.                 float       lean;
  105.                 float       peekOver;
  106.                 float       priority;
  107.                 float       minDistanceToTarget;
  108.                 float       maxDistanceToTarget;
  109.                 EStance     stance;
  110.                 PostureID   parentID;
  111.                 bool        enabled;
  112.                 string      agInput;
  113.                 string      name;
  114.         };
  115.  
  116.         PostureManager();
  117.         ~PostureManager();
  118.  
  119.         void           ResetPostures();
  120.         void           AddDefaultPostures(PostureType type);
  121.  
  122.         PostureID      AddPosture(const PostureInfo& posture);
  123.         void           SetPosture(PostureID postureID, const PostureInfo& posture);
  124.         bool           GetPosture(PostureID postureID, PostureInfo* posture = 0) const;
  125.         PostureID      GetPostureID(const char* postureName) const;
  126.         bool           GetPostureByName(const char* postureName, PostureInfo* posture = 0) const;
  127.         void           SetPosturePriority(PostureID postureID, float priority);
  128.         float          GetPosturePriority(PostureID postureID) const;
  129.  
  130.         PostureQueryID QueryPosture(const PostureQuery& postureQuery);
  131.         void           CancelPostureQuery(PostureQueryID queryID);
  132.         AsyncState     GetPostureQueryResult(PostureQueryID queryID, PostureID* postureID, PostureInfo** postureInfo);
  133.  
  134. private:
  135.         typedef std::vector<PostureInfo> PostureInfos;
  136.         PostureInfos m_postureInfos;
  137.  
  138.         struct RunningPosture
  139.         {
  140.                 RunningPosture(int16 _postureID = -1)
  141.                         : postureID(_postureID)
  142.                         , targetVis(false)
  143.                         , targetAim(false)
  144.                         , eye(ZERO)
  145.                         , weapon(ZERO)
  146.                         , processed(false)
  147.                 {
  148.                 }
  149.  
  150.                 Vec3      eye;
  151.                 Vec3      weapon;
  152.  
  153.                 PostureID postureID;
  154.                 bool      targetVis : 1;
  155.                 bool      targetAim : 1;
  156.                 bool      processed : 1;
  157.         };
  158.  
  159.         struct PostureSorter
  160.         {
  161.                 PostureSorter(const PostureManager& _manager, PostureID _hintPostureID = -1)
  162.                         : manager(_manager)
  163.                         , hintPostureID(_hintPostureID)
  164.                 {
  165.                 }
  166.  
  167.                 bool operator()(const RunningPosture& lhs, const RunningPosture& rhs) const
  168.                 {
  169.                         if (hintPostureID == lhs.postureID)
  170.                                 return true;
  171.  
  172.                         if (hintPostureID == rhs.postureID)
  173.                                 return false;
  174.  
  175.                         return CAISystem::CompareFloatsFPUBugWorkaround(manager.GetPosturePriority(lhs.postureID),
  176.                                                                         manager.GetPosturePriority(rhs.postureID));
  177.                 }
  178.  
  179.                 PostureID             hintPostureID;
  180.                 const PostureManager& manager;
  181.         };
  182.  
  183.         struct StickyStancePostureSorter
  184.         {
  185.                 StickyStancePostureSorter(const PostureManager& _manager, const PostureInfos& _infos, EStance _stickyStance,
  186.                                           PostureID _hintPostureID = -1)
  187.                         : manager(_manager)
  188.                         , infos(_infos)
  189.                         , stickyStance(_stickyStance)
  190.                         , hintPostureID(_hintPostureID)
  191.                 {
  192.                 }
  193.  
  194.                 bool operator()(const RunningPosture& lhs, const RunningPosture& rhs) const
  195.                 {
  196.                         if (hintPostureID == lhs.postureID)
  197.                                 return true;
  198.  
  199.                         if (hintPostureID == rhs.postureID)
  200.                                 return false;
  201.  
  202.                         EStance lhsStance = infos[lhs.postureID].stance;
  203.                         EStance rhsStance = infos[rhs.postureID].stance;
  204.  
  205.                         if (lhsStance != rhsStance)
  206.                         {
  207.                                 if (lhsStance == stickyStance)
  208.                                         return true;
  209.                                 else if (rhsStance == stickyStance)
  210.                                         return false;
  211.                         }
  212.  
  213.                         return CAISystem::CompareFloatsFPUBugWorkaround(manager.GetPosturePriority(lhs.postureID),
  214.                                                                         manager.GetPosturePriority(rhs.postureID));
  215.                 }
  216.  
  217.                 const PostureInfos&   infos;
  218.                 EStance               stickyStance;
  219.                 PostureID             hintPostureID;
  220.                 const PostureManager& manager;
  221.         };
  222.  
  223.         struct QueuedPostureCheck
  224.         {
  225.                 QueuedRayID leanabilityRayID;
  226.                 QueuedRayID visibilityRayID;
  227.                 QueuedRayID aimabilityRayID;
  228.  
  229.                 PostureID   postureID;
  230.  
  231.                 uint8       awaitingResultCount;
  232.                 uint8       positiveResultCount;
  233.         };
  234.  
  235.         typedef std::vector<QueuedPostureCheck> QueuedPostureChecks;
  236.  
  237.         struct QueuedQuery
  238.         {
  239.                 QueuedQuery()
  240.                         : queryID(0)
  241.                         , status(AsyncFailed)
  242.                         , result(-1)
  243.                 {
  244.                 }
  245.  
  246.                 PostureQueryID      queryID;
  247.                 AsyncState          status;
  248.                 PostureID           result;
  249.                 QueuedPostureChecks postureChecks;
  250.         };
  251.  
  252.         typedef std::vector<QueuedQuery> QueuedPostureQueries;
  253.         QueuedPostureQueries m_queue;
  254.  
  255.         PostureQueryID       m_queryGenID;
  256.         uint32               m_queueTail;
  257.         uint32               m_queueSize;
  258.  
  259.         enum
  260.         {
  261.                 TotalCheckCount = 3,
  262.         };
  263.         void CancelRays(QueuedQuery& query);
  264.         void RayComplete(const QueuedRayID& rayID, const RayCastResult& result);
  265. };
  266.  
  267. #endif
  268.  
downloadPostureManager.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