BVB Source Codes

CRYENGINE Show WorldQuery.h Source code

Return Download CRYENGINE: download WorldQuery.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __WORLDQUERY_H__
  4. #define __WORLDQUERY_H__
  5.  
  6. #pragma once
  7.  
  8. #include "IWorldQuery.h"
  9.  
  10. #if 1
  11.         #define WORLDQUERY_USE_DEFERRED_LINETESTS 1
  12. #else // deprecated and won't compile
  13.         #define WORLDQUERY_USE_DEFERRED_LINETESTS 0
  14. #endif
  15.  
  16. #if WORLDQUERY_USE_DEFERRED_LINETESTS
  17.         #include "CryActionPhysicQueues.h"
  18. #endif
  19.  
  20. struct IActor;
  21. struct IViewSystem;
  22.  
  23. class CWorldQuery : public CGameObjectExtensionHelper<CWorldQuery, IWorldQuery>
  24. {
  25. private:
  26.  
  27. #if WORLDQUERY_USE_DEFERRED_LINETESTS
  28.         struct SRayInfo
  29.         {
  30.                 SRayInfo()
  31.                         : rayId(0)
  32.                         , counter(0)
  33.                 {
  34.  
  35.                 }
  36.  
  37.                 void Reset()
  38.                 {
  39.                         if (rayId != 0)
  40.                         {
  41.                                 CCryAction::GetCryAction()->GetPhysicQueues().GetRayCaster().Cancel(rayId);
  42.                                 rayId = 0;
  43.                         }
  44.                         counter = 0;
  45.                 }
  46.  
  47.                 QueuedRayID rayId;
  48.                 uint32      counter;
  49.         };
  50. #endif
  51.  
  52. public:
  53.         CWorldQuery();
  54.         ~CWorldQuery();
  55.  
  56.         // IGameObjectExtension
  57.         virtual bool                 Init(IGameObject* pGameObject);
  58.         virtual void                 InitClient(int channelId)                                                       {};
  59.         virtual void                 PostInit(IGameObject* pGameObject);
  60.         virtual void                 PostInitClient(int channelId)                                                   {};
  61.         virtual bool                 ReloadExtension(IGameObject* pGameObject, const SEntitySpawnParams& params);
  62.         virtual void                 PostReloadExtension(IGameObject* pGameObject, const SEntitySpawnParams& params) {}
  63.         virtual void                 Release();
  64.         virtual void                 FullSerialize(TSerialize ser);
  65.         virtual bool                 NetSerialize(TSerialize ser, EEntityAspects aspect, uint8 profile, int flags) { return true; }
  66.         virtual void                 PostSerialize()                                                               {}
  67.         virtual void                 SerializeSpawnInfo(TSerialize ser)                                            {}
  68.         virtual ISerializableInfoPtr GetSpawnInfo()                                                                { return 0; }
  69.         virtual void                 Update(SEntityUpdateContext& ctx, int slot);
  70.         virtual void                 HandleEvent(const SGameObjectEvent&);
  71.         virtual void                 ProcessEvent(SEntityEvent&) {}
  72.         virtual void                 SetChannelId(uint16 id)     {};
  73.         virtual void                 SetAuthority(bool auth)     {}
  74.         virtual void                 PostUpdate(float frameTime) { CRY_ASSERT(false); }
  75.         virtual void                 PostRemoteSpawn()           {};
  76.         virtual void                 GetMemoryUsage(ICrySizer* pSizer) const;
  77.         // ~IGameObjectExtension
  78.  
  79.         ILINE void SetProximityRadius(float n)
  80.         {
  81.                 m_proximityRadius = n;
  82.                 m_validQueries &= ~(eWQ_Proximity | eWQ_InFrontOf);
  83.         }
  84.  
  85.         ILINE const ray_hit* RaycastQuery()
  86.         {
  87.                 return GetLookAtPoint(m_proximityRadius);
  88.         }
  89.  
  90.         ILINE const ray_hit* GetLookAtPoint(const float fMaxDist = 0, bool ignoreGlass = false)
  91.         {
  92.                 ValidateQuery(eWQ_Raycast);
  93.  
  94.                 if (m_rayHitAny)
  95.                 {
  96.                         const ray_hit* hit = !ignoreGlass && m_rayHitPierceable.dist >= 0.f ? &m_rayHitPierceable : &m_rayHitSolid;
  97.  
  98.                         if ((fMaxDist <= 0) || (hit->dist <= fMaxDist))
  99.                         {
  100.                                 return hit;
  101.                         }
  102.                 }
  103.                 return NULL;
  104.         }
  105.  
  106.         ILINE const ray_hit* GetBehindPoint(const float fMaxDist = 0)
  107.         {
  108.                 ValidateQuery(eWQ_BackRaycast);
  109.                 if (m_backRayHitAny)
  110.                 {
  111.                         if ((fMaxDist > 0) && (m_backRayHit.dist <= fMaxDist))
  112.                         {
  113.                                 return &m_backRayHit;
  114.                         }
  115.                 }
  116.                 return NULL;
  117.         }
  118.  
  119.         ILINE const EntityId GetLookAtEntityId(bool ignoreGlass = false)
  120.         {
  121.                 ValidateQuery(eWQ_Raycast);
  122.  
  123.                 return !ignoreGlass && m_rayHitPierceable.dist >= 0.f ? 0 : m_lookAtEntityId;
  124.         }
  125.  
  126.         ILINE const EntityId* ProximityQuery(int& numberOfEntities)
  127.         {
  128.                 ValidateQuery(eWQ_Proximity);
  129.                 numberOfEntities = m_proximity.size();
  130.                 return numberOfEntities ? &m_proximity[0] : 0;
  131.         }
  132.  
  133.         ILINE const Entities& ProximityQuery()
  134.         {
  135.                 ValidateQuery(eWQ_Proximity);
  136.                 return m_proximity;
  137.         }
  138.  
  139.         ILINE const Entities& InFrontOfQuery()
  140.         {
  141.                 ValidateQuery(eWQ_InFrontOf);
  142.                 return m_inFrontOf;
  143.         }
  144.         ILINE IEntity* GetEntityInFrontOf()
  145.         {
  146.                 const Entities& entities = InFrontOfQuery();
  147.                 if (entities.empty())
  148.                         return NULL;
  149.                 else
  150.                         return m_pEntitySystem->GetEntity(entities[0]);
  151.         }
  152.         ILINE const Entities& GetEntitiesInFrontOf()
  153.         {
  154.                 return InFrontOfQuery();
  155.         }
  156.  
  157.         ILINE const EntityId* GetEntitiesAround(int& num)
  158.         {
  159.                 ValidateQuery(eWQ_EntitiesAround);
  160.                 num = m_EntAroundOf.size();
  161.                 return num ? &m_EntAroundOf[0] : 0;
  162.         }
  163.  
  164.         ILINE IPhysicalEntity* const* GetPhysicalEntitiesAround(int& num)
  165.         {
  166.                 ValidateQuery(eWQ_PhysicalEntitiesAround);
  167.                 num = m_PhysEntAroundOf.size();
  168.                 return num ? &m_PhysEntAroundOf[0] : 0;
  169.         }
  170.  
  171.         ILINE IPhysicalEntity* GetPhysicalEntityInFrontOf()
  172.         {
  173.                 ValidateQuery(eWQ_PhysicalEntitiesInFrontOf);
  174.  
  175.                 return gEnv->pPhysicalWorld->GetPhysicalEntityById(m_physicalEntityInFrontOf);
  176.         }
  177.  
  178.         ILINE const Vec3& GetPos() const { return m_worldPosition; }
  179.         ILINE const Vec3& GetDir() const { return m_dir; }
  180.  
  181. #if WORLDQUERY_USE_DEFERRED_LINETESTS
  182.         void OnRayCastDataReceived(const QueuedRayID& rayID, const RayCastResult& result);
  183. #endif
  184.  
  185. private:
  186.         uint32 m_validQueries;
  187.         int    m_renderFrameId;
  188.  
  189.         float  m_proximityRadius;
  190.  
  191.         // keep in sync with m_updateQueryFunctions
  192.         enum EWorldQuery
  193.         {
  194.                 eWQ_Raycast = 0,
  195.                 eWQ_Proximity,
  196.                 eWQ_InFrontOf,
  197.                 eWQ_BackRaycast,
  198.                 eWQ_EntitiesAround,
  199.                 eWQ_PhysicalEntitiesAround,
  200.                 eWQ_PhysicalEntitiesInFrontOf,
  201.         };
  202.         typedef void (CWorldQuery::* UpdateQueryFunction)();
  203.  
  204.         Vec3                       m_worldPosition;
  205.         Vec3                       m_dir;
  206.         IActor*                    m_pActor;
  207.         static UpdateQueryFunction m_updateQueryFunctions[];
  208.  
  209.         IPhysicalWorld*            m_pPhysWorld;
  210.         IEntitySystem*             m_pEntitySystem;
  211.         IViewSystem*               m_pViewSystem;
  212.  
  213. #if WORLDQUERY_USE_DEFERRED_LINETESTS
  214.         int GetRaySlot();
  215.         int GetSlotForRay(const QueuedRayID& rayId) const;
  216.  
  217.         static const int kMaxQueuedRays = 6;
  218.         SRayInfo         m_queuedRays[kMaxQueuedRays];
  219.         uint32           m_requestCounter;
  220.         float            m_timeLastDeferredResult;
  221. #endif
  222.  
  223.         // ray-cast query
  224.         bool    m_rayHitAny;
  225.         ray_hit m_rayHitSolid;
  226.         ray_hit m_rayHitPierceable;
  227.  
  228.         // back raycast query
  229.         bool    m_backRayHitAny;
  230.         ray_hit m_backRayHit;
  231.  
  232.         //the entity the object is currently looking at...
  233.         EntityId m_lookAtEntityId;
  234.  
  235.         // proximity query
  236.         Entities                      m_proximity;
  237.         // "in-front-of" query
  238.         Entities                      m_inFrontOf;
  239.  
  240.         Entities                      m_EntAroundOf;
  241.         std::vector<IPhysicalEntity*> m_PhysEntAroundOf;
  242.  
  243.         int                           m_physicalEntityInFrontOf;
  244.  
  245.         ILINE void ValidateQuery(EWorldQuery query)
  246.         {
  247.                 uint32 queryMask = 1u << query;
  248.  
  249.                 int frameid = gEnv->nMainFrameID;
  250.                 if (m_renderFrameId != frameid)
  251.                 {
  252.                         m_renderFrameId = frameid;
  253.                         m_validQueries = 0;
  254.                 }
  255.                 else
  256.                 {
  257.                         if (m_validQueries & queryMask)
  258.                                 return;
  259.                 }
  260.                 (this->*(m_updateQueryFunctions[query]))();
  261.                 m_validQueries |= queryMask;
  262.         }
  263.  
  264.         void UpdateRaycastQuery();
  265.         void UpdateProximityQuery();
  266.         void UpdateInFrontOfQuery();
  267.         void UpdateBackRaycastQuery();
  268.         void UpdateEntitiesAround();
  269.         void UpdatePhysicalEntitiesAround();
  270.         void UpdatePhysicalEntityInFrontOf();
  271. };
  272.  
  273. #endif
  274.  
downloadWorldQuery.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