BVB Source Codes

CRYENGINE Show AIObjectIterators.h Source code

Return Download CRYENGINE: download AIObjectIterators.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef AIOBJECT_ITERS_H
  4. #define AIOBJECT_ITERS_H
  5.  
  6. //TODO get rid of everything in this file and replace it with something better!  Yuk!
  7.  
  8. // Little helper template
  9. // T should be in practice a CWeakRef<CAIObject> , CCountedRef<CAIObject>, etc.
  10. template<template<typename> class T> struct ObjMapIter
  11. {
  12.         typedef typename std::multimap<short, T<CAIObject>>::iterator Type;
  13. };
  14.  
  15. //====================================================================
  16. // SAIObjectMapIter
  17. // Specialized next for iterating over the whole container.
  18. //====================================================================
  19. template<template<typename> class T> struct SAIObjectMapIter : public IAIObjectIter
  20. {
  21.         typedef typename ObjMapIter<T>::Type Iter;
  22.  
  23.         SAIObjectMapIter(Iter first, Iter end) :
  24.                 m_it(first), m_end(end), m_ai(0)
  25.         {
  26.         }
  27.  
  28.         virtual IAIObject* GetObject()
  29.         {
  30.                 if (!m_ai && m_it != m_end)
  31.                         Next();
  32.                 return m_ai;
  33.         }
  34.  
  35.         virtual void Release()
  36.         {
  37.                 // (MATT) Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/04})
  38.                 this->~SAIObjectMapIter();
  39.                 pool.push_back(this);
  40.         }
  41.  
  42.         // (MATT) (was) Update the pointer from the current iterator if it's valid.
  43.         //        (now) That, and keep advancing if the ref is not valid {2009/03/27}
  44.         virtual void Next()
  45.         {
  46.                 for (m_ai = NULL; !m_ai && m_it != m_end; ++m_it)
  47.                         m_ai = m_it->second.GetAIObject();
  48.         }
  49.  
  50.         static SAIObjectMapIter* Allocate(Iter first, Iter end)
  51.         {
  52.                 if (pool.empty())
  53.                 {
  54.                         return new SAIObjectMapIter(first, end);
  55.                 }
  56.                 else
  57.                 {
  58.                         SAIObjectMapIter* res = pool.back();
  59.                         pool.pop_back();
  60.                         return new(res) SAIObjectMapIter(first, end);
  61.                 }
  62.         }
  63.  
  64.         IAIObject* m_ai;
  65.         Iter       m_it;
  66.         Iter       m_end;
  67.  
  68. private:
  69.         friend void ClearAIObjectIteratorPools();
  70.         static std::vector<SAIObjectMapIter*> pool;
  71. };
  72.  
  73. //====================================================================
  74. // SAIObjectMapIterOfType
  75. // Iterator base for iterating over 'AIObjects' container.
  76. // Returns only objects of specified type.
  77. //====================================================================
  78. template<template<typename> class T> struct SAIObjectMapIterOfType : public SAIObjectMapIter<T>
  79. {
  80.         typedef typename SAIObjectMapIter<T>::Iter Iter;
  81.  
  82.         using SAIObjectMapIter<T>::m_ai;
  83.         using SAIObjectMapIter<T>::m_it;
  84.         using SAIObjectMapIter<T>::m_end;
  85.  
  86.         SAIObjectMapIterOfType(short n, Iter first, Iter end) :
  87.                 m_n(n), SAIObjectMapIter<T>(first, end) {}
  88.  
  89.         virtual void Release()
  90.         {
  91.                 // (MATT) Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/04})
  92.                 this->~SAIObjectMapIterOfType();
  93.                 pool.push_back(this);
  94.         }
  95.  
  96.         static SAIObjectMapIterOfType* Allocate(short n, Iter first, Iter end)
  97.         {
  98.                 if (pool.empty())
  99.                 {
  100.                         return new SAIObjectMapIterOfType(n, first, end);
  101.                 }
  102.                 else
  103.                 {
  104.                         SAIObjectMapIterOfType* res = pool.back();
  105.                         pool.pop_back();
  106.                         return new(res) SAIObjectMapIterOfType(n, first, end);
  107.                 }
  108.         }
  109.  
  110.         virtual void Next()
  111.         {
  112.                 for (m_ai = NULL; !m_ai && m_it != m_end; ++m_it)
  113.                 {
  114.                         // Constraint to type
  115.                         if (m_it->first != m_n)
  116.                         {
  117.                                 m_it = m_end;
  118.                                 break;
  119.                         }
  120.                         else
  121.                         {
  122.                                 m_ai = m_it->second.GetAIObject();
  123.                         }
  124.                 }
  125.         }
  126.  
  127.         short m_n;
  128.  
  129. private:
  130.         friend void ClearAIObjectIteratorPools();
  131.         static std::vector<SAIObjectMapIterOfType*> pool;
  132. };
  133.  
  134. //====================================================================
  135. // SAIObjectMapIterOfTypeInRange
  136. // Specialized next for iterating over the whole container.
  137. // Returns only objects which are enclosed by the specified sphere and of specified type.
  138. //====================================================================
  139. template<template<typename> class T> struct SAIObjectMapIterOfTypeInRange : public SAIObjectMapIter<T>
  140. {
  141.         typedef typename SAIObjectMapIter<T>::Iter Iter;
  142.  
  143.         using SAIObjectMapIter<T>::m_ai;
  144.         using SAIObjectMapIter<T>::m_it;
  145.         using SAIObjectMapIter<T>::m_end;
  146.  
  147.         SAIObjectMapIterOfTypeInRange(short n, Iter first, Iter end, const Vec3& center, float rad, bool check2D) :
  148.                 m_n(n), m_center(center), m_rad(rad), m_check2D(check2D), SAIObjectMapIter<T>(first, end) {}
  149.  
  150.         virtual void Release()
  151.         {
  152.                 // (MATT) Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/04})
  153.                 this->~SAIObjectMapIterOfTypeInRange();
  154.                 pool.push_back(this);
  155.         }
  156.  
  157.         static SAIObjectMapIterOfTypeInRange* Allocate(short n, Iter first, Iter end, const Vec3& center, float rad, bool check2D)
  158.         {
  159.                 if (pool.empty())
  160.                 {
  161.                         return new SAIObjectMapIterOfTypeInRange(n, first, end, center, rad, check2D);
  162.                 }
  163.                 else
  164.                 {
  165.                         SAIObjectMapIterOfTypeInRange* res = pool.back();
  166.                         pool.pop_back();
  167.                         return new(res) SAIObjectMapIterOfTypeInRange(n, first, end, center, rad, check2D);
  168.                 }
  169.         }
  170.  
  171.         virtual void Next()
  172.         {
  173.                 for (m_ai = NULL; !m_ai && m_it != m_end; ++m_it)
  174.                 {
  175.                         // Constraint to type
  176.                         if (m_it->first != m_n)
  177.                         {
  178.                                 m_it = m_end;
  179.                                 break;
  180.                         }
  181.  
  182.                         CAIObject* pObj = m_it->second.GetAIObject();
  183.                         if (!pObj)
  184.                                 continue;
  185.  
  186.                         // Constraint to sphere
  187.                         if (m_check2D)
  188.                         {
  189.                                 if (Distance::Point_Point2DSq(m_center, pObj->GetPos()) < sqr(pObj->GetRadius() + m_rad))
  190.                                         m_ai = pObj;
  191.                         }
  192.                         else
  193.                         {
  194.                                 if (Distance::Point_PointSq(m_center, pObj->GetPos()) < sqr(pObj->GetRadius() + m_rad))
  195.                                         m_ai = pObj;
  196.                         }
  197.                 }
  198.         }
  199.  
  200.         short m_n;
  201.         Vec3  m_center;
  202.         float m_rad;
  203.         bool  m_check2D;
  204.  
  205. private:
  206.         friend void ClearAIObjectIteratorPools();
  207.         static std::vector<SAIObjectMapIterOfTypeInRange*> pool;
  208. };
  209.  
  210. //====================================================================
  211. // SAIObjectMapIterInRange
  212. // Iterator base for iterating over 'AIObjects' container.
  213. // Returns only objects which are enclosed by the specified sphere.
  214. //====================================================================
  215. template<template<typename> class T> struct SAIObjectMapIterInRange : public SAIObjectMapIter<T>
  216. {
  217.         typedef typename ObjMapIter<T>::Type Iter;
  218.  
  219.         using SAIObjectMapIter<T>::m_ai;
  220.         using SAIObjectMapIter<T>::m_it;
  221.         using SAIObjectMapIter<T>::m_end;
  222.  
  223.         SAIObjectMapIterInRange(Iter first, Iter end, const Vec3& center, float rad, bool check2D) :
  224.                 m_center(center), m_rad(rad), m_check2D(check2D), SAIObjectMapIter<T>(first, end) {}
  225.  
  226.         virtual void Release()
  227.         {
  228.                 // (MATT) Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/04})
  229.                 this->~SAIObjectMapIterInRange();
  230.                 pool.push_back(this);
  231.         }
  232.  
  233.         static SAIObjectMapIterInRange* Allocate(Iter first, Iter end, const Vec3& center, float rad, bool check2D)
  234.         {
  235.                 if (pool.empty())
  236.                 {
  237.                         return new SAIObjectMapIterInRange(first, end, center, rad, check2D);
  238.                 }
  239.                 else
  240.                 {
  241.                         SAIObjectMapIterInRange* res = pool.back();
  242.                         pool.pop_back();
  243.                         return new(res) SAIObjectMapIterInRange(first, end, center, rad, check2D);
  244.                 }
  245.         }
  246.  
  247.         virtual void Next()
  248.         {
  249.                 for (m_ai = NULL; !m_ai && m_it != m_end; ++m_it)
  250.                 {
  251.                         CAIObject* pObj = m_it->second.GetAIObject();
  252.                         if (!pObj)
  253.                                 continue;
  254.  
  255.                         // Constraint to sphere
  256.                         if (m_check2D)
  257.                         {
  258.                                 if (Distance::Point_Point2DSq(m_center, pObj->GetPos()) < sqr(pObj->GetRadius() + m_rad))
  259.                                         m_ai = pObj;
  260.                         }
  261.                         else
  262.                         {
  263.                                 if (Distance::Point_PointSq(m_center, pObj->GetPos()) < sqr(pObj->GetRadius() + m_rad))
  264.                                         m_ai = pObj;
  265.                         }
  266.                 }
  267.  
  268.         }
  269.  
  270.         Vec3  m_center;
  271.         float m_rad;
  272.         bool  m_check2D;
  273.  
  274. private:
  275.         friend void ClearAIObjectIteratorPools();
  276.         static std::vector<SAIObjectMapIterInRange*> pool;
  277. };
  278.  
  279. //====================================================================
  280. // SAIObjectMapIterInShape
  281. // Iterator base for iterating over 'AIObjects' container.
  282. // Returns only objects which are enclosed by the specified shape.
  283. //====================================================================
  284. template<template<typename> class T> struct SAIObjectMapIterInShape : public SAIObjectMapIter<T>
  285. {
  286.         typedef typename SAIObjectMapIter<T>::Iter Iter;
  287.  
  288.         using SAIObjectMapIter<T>::m_ai;
  289.         using SAIObjectMapIter<T>::m_it;
  290.         using SAIObjectMapIter<T>::m_end;
  291.  
  292.         SAIObjectMapIterInShape(Iter first, Iter end, const SShape& shape, bool checkHeight) :
  293.                 m_shape(shape), m_checkHeight(checkHeight), SAIObjectMapIter<T>(first, end) {}
  294.  
  295.         virtual void Release()
  296.         {
  297.                 // (MATT) Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/04})
  298.                 this->~SAIObjectMapIterInShape();
  299.                 pool.push_back(this);
  300.         }
  301.  
  302.         static SAIObjectMapIterInShape* Allocate(Iter first, Iter end, const SShape& shape, bool checkHeight)
  303.         {
  304.                 if (pool.empty())
  305.                 {
  306.                         return new SAIObjectMapIterInShape(first, end, shape, checkHeight);
  307.                 }
  308.                 else
  309.                 {
  310.                         SAIObjectMapIterInShape* res = pool.back();
  311.                         pool.pop_back();
  312.                         return new(res) SAIObjectMapIterInShape(first, end, shape, checkHeight);
  313.                 }
  314.         }
  315.  
  316.         virtual void Next()
  317.         {
  318.                 for (m_ai = NULL; !m_ai && m_it != m_end; ++m_it)
  319.                 {
  320.                         CAIObject* pObj = m_it->second.GetAIObject();
  321.                         if (!pObj)
  322.                                 continue;
  323.  
  324.                         // Constraint to shape
  325.                         if (m_shape.IsPointInsideShape(pObj->GetPos(), m_checkHeight))
  326.                                 m_ai = pObj;
  327.                 }
  328.         }
  329.  
  330.         const SShape& m_shape;
  331.         bool          m_checkHeight;
  332.  
  333. private:
  334.         friend void ClearAIObjectIteratorPools();
  335.         static std::vector<SAIObjectMapIterInShape*> pool;
  336. };
  337.  
  338. //====================================================================
  339. // SAIObjectMapIterOfTypeInRange
  340. // Specialized next for iterating over the whole container.
  341. // Returns only objects which are enclosed by the specified shape and of specified type.
  342. //====================================================================
  343. template<template<typename> class T> struct SAIObjectMapIterOfTypeInShape : public SAIObjectMapIter<T>
  344. {
  345.         typedef typename SAIObjectMapIter<T>::Iter Iter;
  346.  
  347.         using SAIObjectMapIter<T>::m_ai;
  348.         using SAIObjectMapIter<T>::m_it;
  349.         using SAIObjectMapIter<T>::m_end;
  350.  
  351.         SAIObjectMapIterOfTypeInShape(short n, Iter first, Iter end, const SShape& shape, bool checkHeight) :
  352.                 m_n(n), m_shape(shape), m_checkHeight(checkHeight), SAIObjectMapIter<T>(first, end) {}
  353.  
  354.         virtual void Release()
  355.         {
  356.                 // (MATT) Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/04})
  357.                 this->~SAIObjectMapIterOfTypeInShape();
  358.                 pool.push_back(this);
  359.         }
  360.  
  361.         static SAIObjectMapIterOfTypeInShape* Allocate(short n, Iter first, Iter end, const SShape& shape, bool checkHeight)
  362.         {
  363.                 if (pool.empty())
  364.                 {
  365.                         return new SAIObjectMapIterOfTypeInShape(n, first, end, shape, checkHeight);
  366.                 }
  367.                 else
  368.                 {
  369.                         SAIObjectMapIterOfTypeInShape* res = pool.back();
  370.                         pool.pop_back();
  371.                         return new(res) SAIObjectMapIterOfTypeInShape(n, first, end, shape, checkHeight);
  372.                 }
  373.         }
  374.  
  375.         virtual void Next()
  376.         {
  377.                 for (m_ai = NULL; !m_ai && m_it != m_end; ++m_it)
  378.                 {
  379.                         // Constraint to type
  380.                         if (m_it->first != m_n)
  381.                         {
  382.                                 m_it = m_end;
  383.                                 break;
  384.                         }
  385.  
  386.                         CAIObject* pObj = m_it->second.GetAIObject();
  387.                         if (!pObj)
  388.                                 continue;
  389.  
  390.                         // Constraint to shape
  391.                         if (m_shape.IsPointInsideShape(pObj->GetPos(), m_checkHeight))
  392.                                 m_ai = pObj;
  393.                 }
  394.         }
  395.  
  396.         short         m_n;
  397.         const SShape& m_shape;
  398.         bool          m_checkHeight;
  399.  
  400. private:
  401.         friend void ClearAIObjectIteratorPools();
  402.         static std::vector<SAIObjectMapIterOfTypeInShape*> pool;
  403. };
  404.  
  405. // (MATT) Iterators now have their destructors called before they enter the pool - so we only need to free the memory here {2008/12/04}
  406. template<template<typename> class T> void DeleteAIObjectMapIter(SAIObjectMapIter<T>* ptr) { operator delete(ptr); }
  407.  
  408. //===================================================================
  409. // ClearAIObjectIteratorPools
  410. //===================================================================
  411. void ClearAIObjectIteratorPools();
  412.  
  413. #endif
  414.  
downloadAIObjectIterators.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