BVB Source Codes

CRYENGINE Show FlowEntityIterator.cpp Source code

Return Download CRYENGINE: download FlowEntityIterator.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4.  
  5. #include <CryFlowGraph/IFlowBaseNode.h>
  6. #include <CryEntitySystem/IEntitySystem.h>
  7. #include <IActorSystem.h>
  8. #include <IVehicleSystem.h>
  9. #include <IItemSystem.h>
  10.  
  11. #define ADD_BASE_INPUTS_ENTITY_ITER()                                                                                           \
  12.   InputPortConfig_Void("Start", _HELP("Call to start iterating through all entities inside the defined sphere")),               \
  13.   InputPortConfig_Void("Next", _HELP("Call to get next entity found")),                                                         \
  14.   InputPortConfig<int>("Limit", 0, _HELP("Limit how many entities are returned. Use 0 to get all entities")),                   \
  15.   InputPortConfig<bool>("Immediate", false, _HELP("TRUE to iterate immediately through results, without having to call Next")), \
  16.   InputPortConfig<int>("Type", 0, _HELP("Type of entity to iterate"), 0, _UICONFIG(ENTITY_TYPE_ENUM))
  17.  
  18. #define ADD_BASE_OUTPUTS_ENTITY_ITER()                                                                                      \
  19.   OutputPortConfig<EntityId>("EntityId", _HELP("Called each time an entity is found, with the Id of the entity returned")), \
  20.   OutputPortConfig<int>("Count", _HELP("Called each time an entity is found, with the current count returned")),            \
  21.   OutputPortConfig_Void("Done", _HELP("Called when all entities have been found, false if none"))
  22.  
  23. #define ENTITY_TYPE_ENUM ("enum_int:All=0,AI=1,Actor=2,Vehicle=3,Item=4,Other=5")
  24.  
  25. enum EEntityType
  26. {
  27.         eET_Unknown = 0x00,
  28.         eET_Valid   = 0x01,
  29.         eET_AI      = 0x02,
  30.         eET_Actor   = 0x04,
  31.         eET_Vehicle = 0x08,
  32.         eET_Item    = 0x10,
  33. };
  34.  
  35. bool IsValidType(int requested, const EEntityType& type)
  36. {
  37.         bool bValid = false;
  38.  
  39.         if (requested == 0)
  40.         {
  41.                 bValid = (type & eET_Valid) == eET_Valid;
  42.         }
  43.         else if (requested == 1)
  44.         {
  45.                 bValid = (type & eET_AI) == eET_AI;
  46.         }
  47.         else if (requested == 2)
  48.         {
  49.                 bValid = (type & eET_Actor) == eET_Actor;
  50.         }
  51.         else if (requested == 3)
  52.         {
  53.                 bValid = (type & eET_Vehicle) == eET_Vehicle;
  54.         }
  55.         else if (requested == 4)
  56.         {
  57.                 bValid = (type & eET_Item) == eET_Item;
  58.         }
  59.         else if (requested == 5)
  60.         {
  61.                 bValid = (type == eET_Valid);
  62.         }
  63.  
  64.         return bValid;
  65. }
  66.  
  67. EEntityType GetEntityType(EntityId id)
  68. {
  69.         int type = eET_Unknown;
  70.  
  71.         IEntitySystem* pEntitySystem = gEnv->pEntitySystem;
  72.         if (pEntitySystem)
  73.         {
  74.                 IEntity* pEntity = pEntitySystem->GetEntity(id);
  75.                 if (pEntity)
  76.                 {
  77.                         type = eET_Valid;
  78.  
  79.                         IEntityClass* pClass = pEntity->GetClass();
  80.                         if (pClass)
  81.                         {
  82.                                 const char* className = pClass->GetName();
  83.  
  84.                                 // Check AI
  85.                                 if (pEntity->GetAI())
  86.                                 {
  87.                                         type |= eET_AI;
  88.                                 }
  89.  
  90.                                 // Check actor
  91.                                 IActorSystem* pActorSystem = gEnv->pGameFramework->GetIActorSystem();
  92.                                 if (pActorSystem)
  93.                                 {
  94.                                         IActor* pActor = pActorSystem->GetActor(id);
  95.                                         if (pActor)
  96.                                         {
  97.                                                 type |= eET_Actor;
  98.                                         }
  99.                                 }
  100.  
  101.                                 // Check vehicle
  102.                                 IVehicleSystem* pVehicleSystem = gEnv->pGameFramework->GetIVehicleSystem();
  103.                                 if (pVehicleSystem)
  104.                                 {
  105.                                         if (pVehicleSystem->IsVehicleClass(className))
  106.                                         {
  107.                                                 type |= eET_Vehicle;
  108.                                         }
  109.                                 }
  110.  
  111.                                 // Check item
  112.                                 IItemSystem* pItemSystem = gEnv->pGameFramework->GetIItemSystem();
  113.                                 if (pItemSystem)
  114.                                 {
  115.                                         if (pItemSystem->IsItemClass(className))
  116.                                         {
  117.                                                 type |= eET_Item;
  118.                                         }
  119.                                 }
  120.                         }
  121.                 }
  122.         }
  123.         return (EEntityType)type;
  124. }
  125.  
  126. //-------------------------------------------------------------------------------------
  127. class CFlowBaseIteratorNode : public CFlowBaseNode<eNCT_Instanced>
  128. {
  129. protected:
  130.         enum EInputPorts
  131.         {
  132.                 EIP_Start,
  133.                 EIP_Next,
  134.                 EIP_Limit,
  135.                 EIP_Immediate,
  136.                 EIP_Type,
  137.                 EIP_CustomStart,
  138.         };
  139.  
  140.         enum EOutputPorts
  141.         {
  142.                 EOP_EntityId,
  143.                 EOP_Count,
  144.                 EOP_Done,
  145.                 EOP_CustomStart,
  146.         };
  147.  
  148.         typedef std::list<EntityId> IterList;
  149.         IterList::iterator m_ListIter;
  150.         IterList           m_List;
  151.  
  152.         SActivationInfo*   m_pActInfo;
  153.         bool               m_bImmediate;
  154.         bool               m_bRestart;
  155.         int                m_Count;
  156.         int                m_limit;
  157.         int                m_Iter;
  158.         int                m_type;
  159.         Vec3               m_min;
  160.         Vec3               m_max;
  161.  
  162.         void Reset()
  163.         {
  164.                 m_Iter = 0;
  165.                 m_Count = 0;
  166.                 m_min.zero();
  167.                 m_max.zero();
  168.                 m_List.clear();
  169.                 m_bRestart = false;
  170.                 m_type = GetPortInt(m_pActInfo, EIP_Type);
  171.                 m_limit = GetPortInt(m_pActInfo, EIP_Limit);
  172.                 m_bImmediate = GetPortBool(m_pActInfo, EIP_Immediate);
  173.         }
  174.  
  175.         void Output()
  176.         {
  177.                 if (m_Count > 0)
  178.                 {
  179.                         const int outputCount = m_bImmediate ? m_Count : m_Iter + 1;
  180.                         while (m_Iter < outputCount)
  181.                         {
  182.                                 if (m_limit == 0 || m_Iter <= m_limit)
  183.                                 {
  184.                                         ActivateOutput(m_pActInfo, EOP_EntityId, *m_ListIter++);
  185.                                         ActivateOutput(m_pActInfo, EOP_Count, ++m_Iter);
  186.                                 }
  187.                         }
  188.                 }
  189.  
  190.                 if (m_Iter == m_Count || m_Iter == m_limit)
  191.                 {
  192.                         ActivateOutput(m_pActInfo, EOP_Done, 1);
  193.                         m_bRestart = true;
  194.                 }
  195.         }
  196.  
  197. public:
  198.         CFlowBaseIteratorNode(SActivationInfo* pActInfo)
  199.                 : m_pActInfo(pActInfo)
  200.                 , m_bImmediate(false)
  201.                 , m_bRestart(false)
  202.                 , m_Count(0)
  203.                 , m_limit(0)
  204.                 , m_Iter(0)
  205.                 , m_type(0)
  206.         {
  207.         }
  208.  
  209.         virtual ~CFlowBaseIteratorNode() {};
  210.         virtual bool GetCustomConfiguration(SFlowNodeConfig& config)      { return false; };
  211.         virtual void CalculateMinMax()                                    {};
  212.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser) {};
  213.         virtual void GetConfiguration(SFlowNodeConfig& config)
  214.         {
  215.                 // Define input ports here, in same order as EInputPorts
  216.                 static const SInputPortConfig inputs[] =
  217.                 {
  218.                         ADD_BASE_INPUTS_ENTITY_ITER(),
  219.                         { 0 }
  220.                 };
  221.  
  222.                 // Define output ports here, in same order as EOutputPorts
  223.                 static const SOutputPortConfig outputs[] =
  224.                 {
  225.                         ADD_BASE_OUTPUTS_ENTITY_ITER(),
  226.                         { 0 }
  227.                 };
  228.  
  229.                 if (!GetCustomConfiguration(config))
  230.                 {
  231.                         config.pInputPorts = inputs;
  232.                         config.pOutputPorts = outputs;
  233.                         config.sDescription = _HELP("Base iterator");
  234.                         config.SetCategory(EFLN_APPROVED);
  235.                 }
  236.         }
  237.  
  238.         virtual void GetEntities()
  239.         {
  240.                 IPhysicalEntity** ppList = NULL;
  241.                 IPhysicalWorld* pWorld = gEnv->pPhysicalWorld;
  242.  
  243.                 const int entityCount = pWorld->GetEntitiesInBox(m_min, m_max, ppList, ent_all);
  244.  
  245.                 for (int i = 0; i < entityCount; ++i)
  246.                 {
  247.                         const int id = pWorld->GetPhysicalEntityId(ppList[i]);
  248.                         if (id > 0)
  249.                         {
  250.                                 const EntityId entityId = (EntityId)id;
  251.                                 const EEntityType entityType = GetEntityType((EntityId)id);
  252.                                 if (IsValidType(m_type, GetEntityType(entityId)))
  253.                                 {
  254.                                         m_List.push_back(entityId);
  255.                                         ++m_Count;
  256.                                 }
  257.                         }
  258.                 }
  259.                 m_ListIter = m_List.begin();
  260.         }
  261.  
  262.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  263.         {
  264.                 m_pActInfo = pActInfo;
  265.  
  266.                 switch (event)
  267.                 {
  268.                 case eFE_Activate:
  269.                         {
  270.                                 if (IsPortActive(m_pActInfo, EIP_Start) || m_bRestart)
  271.                                 {
  272.                                         Reset();
  273.                                         CalculateMinMax();
  274.                                         GetEntities();
  275.                                 }
  276.                                 Output();
  277.                                 break;
  278.                         }
  279.                 }
  280.         }
  281.  
  282.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  283.         {
  284.                 return new CFlowBaseIteratorNode(pActInfo);
  285.         }
  286.  
  287.         virtual void GetMemoryUsage(ICrySizer* s) const
  288.         {
  289.                 s->Add(*this);
  290.         }
  291. };
  292.  
  293. //-------------------------------------------------------------------------------------
  294. class CFlowNode_GetEntitiesInSphere : public CFlowBaseIteratorNode
  295. {
  296.         enum ECustomInputPorts
  297.         {
  298.                 EIP_Pos = EIP_CustomStart,
  299.                 EIP_Range,
  300.         };
  301.  
  302. public:
  303.         CFlowNode_GetEntitiesInSphere(SActivationInfo* pActInfo) : CFlowBaseIteratorNode(pActInfo) {}
  304.         virtual ~CFlowNode_GetEntitiesInSphere() {}
  305.  
  306.         virtual bool GetCustomConfiguration(SFlowNodeConfig& config)
  307.         {
  308.                 static const SInputPortConfig inputs[] =
  309.                 {
  310.                         ADD_BASE_INPUTS_ENTITY_ITER(),
  311.                         InputPortConfig<Vec3>("Center",_HELP("Center point of sphere")),
  312.                         InputPortConfig<float>("Range",0.f,                              _HELP("Range i.e., radius of sphere - Distance from center to check for entities")),
  313.                         { 0 }
  314.                 };
  315.  
  316.                 static const SOutputPortConfig outputs[] =
  317.                 {
  318.                         ADD_BASE_OUTPUTS_ENTITY_ITER(),
  319.                         { 0 }
  320.                 };
  321.  
  322.                 config.pInputPorts = inputs;
  323.                 config.pOutputPorts = outputs;
  324.                 config.sDescription = _HELP("Finds and returns all entities that are inside the defined sphere");
  325.                 config.SetCategory(EFLN_APPROVED);
  326.  
  327.                 return true;
  328.         }
  329.  
  330.         virtual void CalculateMinMax()
  331.         {
  332.                 const Vec3& center(GetPortVec3(m_pActInfo, EIP_Pos));
  333.                 const float range = GetPortFloat(m_pActInfo, EIP_Range);
  334.                 const float rangeSq = range * range;
  335.  
  336.                 m_min(center.x - range, center.y - range, center.z - range);
  337.                 m_max(center.x + range, center.y + range, center.z + range);
  338.         }
  339.  
  340.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  341.         {
  342.                 return new CFlowNode_GetEntitiesInSphere(pActInfo);
  343.         }
  344. };
  345.  
  346. //-------------------------------------------------------------------------------------
  347. class CFlowNode_GetEntitiesInBoxByClass : public CFlowBaseNode<eNCT_Instanced>
  348. {
  349. protected:
  350.         enum EInputPorts
  351.         {
  352.                 EIP_Start,
  353.                 EIP_Next,
  354.                 EIP_Limit,
  355.                 EIP_Immediate,
  356.                 EIP_ClassName,
  357.                 EIP_Pos,
  358.                 EIP_Size
  359.         };
  360.  
  361.         enum EOutputPorts
  362.         {
  363.                 EOP_EntityId,
  364.                 EOP_Count,
  365.                 EOP_Done
  366.         };
  367.  
  368.         typedef std::list<EntityId> IterList;
  369.         IterList::iterator m_listIter;
  370.         IterList           m_list;
  371.  
  372.         SActivationInfo*   m_pActInfo;
  373.         bool               m_bImmediate;
  374.         bool               m_bRestart;
  375.         int                m_count;
  376.         int                m_limit;
  377.         int                m_iter;
  378.         string             m_className;
  379.  
  380.         void Reset()
  381.         {
  382.                 m_iter = 0;
  383.                 m_count = 0;
  384.                 m_list.clear();
  385.                 m_bRestart = false;
  386.                 m_className = GetPortString(m_pActInfo, EIP_ClassName);
  387.                 m_limit = GetPortInt(m_pActInfo, EIP_Limit);
  388.                 m_bImmediate = GetPortBool(m_pActInfo, EIP_Immediate);
  389.         }
  390.  
  391.         void Output()
  392.         {
  393.                 if (m_count > 0)
  394.                 {
  395.                         const int outputCount = m_bImmediate ? m_count : m_iter + 1;
  396.                         while (m_iter < outputCount)
  397.                         {
  398.                                 if (m_limit == 0 || m_iter <= m_limit)
  399.                                 {
  400.                                         ActivateOutput(m_pActInfo, EOP_EntityId, *m_listIter++);
  401.                                         ActivateOutput(m_pActInfo, EOP_Count, ++m_iter);
  402.                                 }
  403.                         }
  404.                 }
  405.  
  406.                 if (m_iter == m_count || m_iter == m_limit)
  407.                 {
  408.                         ActivateOutput(m_pActInfo, EOP_Done, 1);
  409.                         m_bRestart = true;
  410.                 }
  411.         }
  412.  
  413. public:
  414.         CFlowNode_GetEntitiesInBoxByClass(SActivationInfo* pActInfo) :
  415.                 m_pActInfo(pActInfo),
  416.                 m_bImmediate(false),
  417.                 m_bRestart(false),
  418.                 m_count(0),
  419.                 m_limit(0),
  420.                 m_iter(0)
  421.         {
  422.         };
  423.  
  424.         virtual ~CFlowNode_GetEntitiesInBoxByClass() {};
  425.  
  426.         virtual void GetConfiguration(SFlowNodeConfig& config)
  427.         {
  428.                 static const SInputPortConfig inputs[] =
  429.                 {
  430.                         InputPortConfig_Void("Start",        _HELP("Call to start iterating through all entities inside the defined sphere")),
  431.                         InputPortConfig_Void("Next",         _HELP("Call to get next entity found")),
  432.                         InputPortConfig<int>("Limit",        0,                                                                               _HELP("Limit how many entities are returned. Use 0 to get all entities")),
  433.                         InputPortConfig<bool>("Immediate",   false,                                                                           _HELP("TRUE to iterate immediately through results, without having to call Next")),
  434.                         InputPortConfig<string>("ClassName", _HELP("Class name of entity to iterate")),
  435.                         InputPortConfig<Vec3>("Center",      _HELP("Center point of the box")),
  436.                         InputPortConfig<float>("Size",       0.f,                                                                             _HELP("Size of the box (from center to any edge) where to check for entities")),
  437.                         { 0 }
  438.                 };
  439.  
  440.                 static const SOutputPortConfig outputs[] =
  441.                 {
  442.                         ADD_BASE_OUTPUTS_ENTITY_ITER(),
  443.                         { 0 }
  444.                 };
  445.  
  446.                 config.pInputPorts = inputs;
  447.                 config.pOutputPorts = outputs;
  448.                 config.sDescription = _HELP("Finds and returns all entities of the given class that are inside the defined box");
  449.                 config.SetCategory(EFLN_APPROVED);
  450.         }
  451.  
  452.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser) {};
  453.  
  454.         virtual void GetEntities()
  455.         {
  456.                 const Vec3& center(GetPortVec3(m_pActInfo, EIP_Pos));
  457.                 const float range = GetPortFloat(m_pActInfo, EIP_Size);
  458.  
  459.                 Vec3 boxMin(center.x - range, center.y - range, center.z - range);
  460.                 Vec3 boxMax(center.x + range, center.y + range, center.z + range);
  461.  
  462.                 IPhysicalEntity** ppList = NULL;
  463.                 const int size = gEnv->pPhysicalWorld->GetEntitiesInBox(boxMin, boxMax, ppList, ent_all);
  464.                 for (int i = 0; i < size; ++i)
  465.                 {
  466.                         const int id = gEnv->pPhysicalWorld->GetPhysicalEntityId(ppList[i]);
  467.                         if (id > 0)
  468.                         {
  469.                                 const IEntitySystem* const pEntitySystem = gEnv->pEntitySystem;
  470.                                 if (pEntitySystem)
  471.                                 {
  472.                                         const EntityId entityId = (EntityId)id;
  473.                                         const IEntity* const pEntity = pEntitySystem->GetEntity(entityId);
  474.                                         if (pEntity)
  475.                                         {
  476.                                                 const IEntityClass* const pClass = pEntity->GetClass();
  477.                                                 if (pClass)
  478.                                                 {
  479.                                                         if (m_className.find(pClass->GetName()) != -1)
  480.                                                         {
  481.                                                                 m_list.push_back(entityId);
  482.                                                                 ++m_count;
  483.                                                         }
  484.                                                 }
  485.                                         }
  486.                                 }
  487.                         }
  488.                 }
  489.                 m_listIter = m_list.begin();
  490.         }
  491.  
  492.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  493.         {
  494.                 m_pActInfo = pActInfo;
  495.  
  496.                 switch (event)
  497.                 {
  498.                 case eFE_Activate:
  499.                         {
  500.                                 if (IsPortActive(m_pActInfo, EIP_Start) || m_bRestart)
  501.                                 {
  502.                                         Reset();
  503.                                         GetEntities();
  504.                                 }
  505.                                 Output();
  506.                                 break;
  507.                         }
  508.                 }
  509.         }
  510.  
  511.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  512.         {
  513.                 return new CFlowNode_GetEntitiesInBoxByClass(pActInfo);
  514.         }
  515.  
  516.         virtual void GetMemoryUsage(ICrySizer* s) const
  517.         {
  518.                 s->Add(*this);
  519.         }
  520. };
  521.  
  522. //-------------------------------------------------------------------------------------
  523. class CFlowNode_GetEntitiesInBox : public CFlowBaseIteratorNode
  524. {
  525.         enum ECustomInputPorts
  526.         {
  527.                 EIP_Min = EIP_CustomStart,
  528.                 EIP_Max,
  529.         };
  530.  
  531. public:
  532.         CFlowNode_GetEntitiesInBox(SActivationInfo* pActInfo) : CFlowBaseIteratorNode(pActInfo) {}
  533.  
  534.         virtual ~CFlowNode_GetEntitiesInBox() {}
  535.  
  536.         virtual bool GetCustomConfiguration(SFlowNodeConfig& config)
  537.         {
  538.                 static const SInputPortConfig inputs[] =
  539.                 {
  540.                         ADD_BASE_INPUTS_ENTITY_ITER(),
  541.                         InputPortConfig<Vec3>("Min",  _HELP("AABB min")),
  542.                         InputPortConfig<Vec3>("Max",  _HELP("AABB max")),
  543.                         { 0 }
  544.                 };
  545.  
  546.                 static const SOutputPortConfig outputs[] =
  547.                 {
  548.                         ADD_BASE_OUTPUTS_ENTITY_ITER(),
  549.                         { 0 }
  550.                 };
  551.  
  552.                 config.pInputPorts = inputs;
  553.                 config.pOutputPorts = outputs;
  554.                 config.sDescription = _HELP("Finds and returns all entities that are inside the defined AABB");
  555.                 config.SetCategory(EFLN_APPROVED);
  556.  
  557.                 return true;
  558.         }
  559.  
  560.         virtual void CalculateMinMax()
  561.         {
  562.                 m_min = GetPortVec3(m_pActInfo, EIP_Min);
  563.                 m_max = GetPortVec3(m_pActInfo, EIP_Max);
  564.         }
  565.  
  566.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  567.         {
  568.                 return new CFlowNode_GetEntitiesInBox(pActInfo);
  569.         }
  570. };
  571.  
  572. //-------------------------------------------------------------------------------------
  573. class CFlowNode_GetEntitiesInArea : public CFlowBaseIteratorNode
  574. {
  575.         enum ECustomInputPorts
  576.         {
  577.                 EIP_Area = EIP_CustomStart,
  578.         };
  579.  
  580. public:
  581.         CFlowNode_GetEntitiesInArea(SActivationInfo* pActInfo) : CFlowBaseIteratorNode(pActInfo) {}
  582.         virtual ~CFlowNode_GetEntitiesInArea() {}
  583.  
  584.         virtual bool GetCustomConfiguration(SFlowNodeConfig& config)
  585.         {
  586.                 static const SInputPortConfig inputs[] =
  587.                 {
  588.                         ADD_BASE_INPUTS_ENTITY_ITER(),
  589.                         InputPortConfig<string>("Area",_HELP("Name of area shape"),  0, 0),
  590.                         { 0 }
  591.                 };
  592.  
  593.                 static const SOutputPortConfig outputs[] =
  594.                 {
  595.                         ADD_BASE_OUTPUTS_ENTITY_ITER(),
  596.                         { 0 }
  597.                 };
  598.  
  599.                 config.pInputPorts = inputs;
  600.                 config.pOutputPorts = outputs;
  601.                 config.sDescription = _HELP("Finds and returns all entities that are inside the area shape with the given name");
  602.                 config.SetCategory(EFLN_APPROVED);
  603.  
  604.                 return true;
  605.         }
  606.  
  607.         virtual void CalculateMinMax()
  608.         {
  609.                 const string area = GetPortString(m_pActInfo, EIP_Area);
  610.  
  611.                 IEntitySystem* pEntitySystem = gEnv->pEntitySystem;
  612.                 if (pEntitySystem)
  613.                 {
  614.                         IEntity* pArea = pEntitySystem->FindEntityByName(area);
  615.                         if (pArea)
  616.                         {
  617.                                 IEntityAreaComponent* pAreaProxy = (IEntityAreaComponent*)pArea->GetProxy(ENTITY_PROXY_AREA);
  618.                                 if (pAreaProxy)
  619.                                 {
  620.                                         Vec3 worldPos(pArea->GetWorldPos());
  621.                                         EEntityAreaType areaType = pAreaProxy->GetAreaType();
  622.  
  623.                                         switch (areaType)
  624.                                         {
  625.                                         case ENTITY_AREA_TYPE_BOX:
  626.                                                 {
  627.                                                         pAreaProxy->GetBox(m_min, m_max);
  628.                                                         m_min += worldPos;
  629.                                                         m_max += worldPos;
  630.                                                         break;
  631.                                                 }
  632.                                         case ENTITY_AREA_TYPE_SPHERE:
  633.                                                 {
  634.                                                         Vec3 center;
  635.                                                         float radius = 0.f;
  636.                                                         pAreaProxy->GetSphere(center, radius);
  637.  
  638.                                                         m_min.Set(center.x - radius, center.y - radius, center.z - radius);
  639.                                                         m_max.Set(center.x + radius, center.y + radius, center.z + radius);
  640.                                                         break;
  641.                                                 }
  642.                                         case ENTITY_AREA_TYPE_SHAPE:
  643.                                                 {
  644.                                                         const Vec3* points = pAreaProxy->GetPoints();
  645.                                                         const int count = pAreaProxy->GetPointsCount();
  646.                                                         if (count > 0)
  647.                                                         {
  648.                                                                 Vec3 p = worldPos + points[0];
  649.                                                                 m_min = p;
  650.                                                                 m_max = p;
  651.                                                                 for (int i = 1; i < count; ++i)
  652.                                                                 {
  653.                                                                         p = worldPos + points[i];
  654.                                                                         if (p.x < m_min.x) m_min.x = p.x;
  655.                                                                         if (p.y < m_min.y) m_min.y = p.y;
  656.                                                                         if (p.z < m_min.z) m_min.z = p.z;
  657.                                                                         if (p.x > m_max.x) m_max.x = p.x;
  658.                                                                         if (p.y > m_max.y) m_max.y = p.y;
  659.                                                                         if (p.z > m_max.z) m_max.z = p.z;
  660.                                                                 }
  661.                                                         }
  662.                                                         break;
  663.                                                 }
  664.                                         }
  665.                                 }
  666.                         }
  667.                 }
  668.         }
  669.  
  670.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  671.         {
  672.                 return new CFlowNode_GetEntitiesInArea(pActInfo);
  673.         }
  674. };
  675.  
  676. //-------------------------------------------------------------------------------------
  677. class CFlowNode_GetEntities : public CFlowBaseIteratorNode
  678. {
  679.  
  680. public:
  681.         CFlowNode_GetEntities(SActivationInfo* pActInfo) : CFlowBaseIteratorNode(pActInfo) {}
  682.         virtual ~CFlowNode_GetEntities() {}
  683.  
  684.         virtual bool GetCustomConfiguration(SFlowNodeConfig& config)
  685.         {
  686.                 static const SInputPortConfig inputs[] =
  687.                 {
  688.                         ADD_BASE_INPUTS_ENTITY_ITER(),
  689.                         { 0 }
  690.                 };
  691.  
  692.                 static const SOutputPortConfig outputs[] =
  693.                 {
  694.                         ADD_BASE_OUTPUTS_ENTITY_ITER(),
  695.                         { 0 }
  696.                 };
  697.  
  698.                 config.pInputPorts = inputs;
  699.                 config.pOutputPorts = outputs;
  700.                 config.sDescription = _HELP("Finds and returns all entities in the world");
  701.                 config.SetCategory(EFLN_APPROVED);
  702.  
  703.                 return true;
  704.         }
  705.  
  706.         virtual void GetEntities()
  707.         {
  708.                 IEntitySystem* pEntitySystem = gEnv->pEntitySystem;
  709.                 if (pEntitySystem)
  710.                 {
  711.                         IEntityItPtr iter = pEntitySystem->GetEntityIterator();
  712.                         if (iter)
  713.                         {
  714.                                 iter->MoveFirst();
  715.                                 IEntity* pEntity = NULL;
  716.                                 while (!iter->IsEnd())
  717.                                 {
  718.                                         pEntity = iter->Next();
  719.                                         if (pEntity)
  720.                                         {
  721.                                                 const EntityId id = pEntity->GetId();
  722.                                                 const EEntityType entityType = GetEntityType(id);
  723.                                                 if (IsValidType(m_type, entityType))
  724.                                                 {
  725.                                                         m_List.push_back(id);
  726.                                                         ++m_Count;
  727.                                                 }
  728.                                         }
  729.                                 }
  730.                         }
  731.                 }
  732.                 m_ListIter = m_List.begin();
  733.         }
  734.  
  735.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  736.         {
  737.                 return new CFlowNode_GetEntities(pActInfo);
  738.         }
  739. };
  740.  
  741. REGISTER_FLOW_NODE("Iterator:GetEntitiesInSphere", CFlowNode_GetEntitiesInSphere);
  742. REGISTER_FLOW_NODE("Iterator:GetEntitiesInBox", CFlowNode_GetEntitiesInBox);
  743. REGISTER_FLOW_NODE("Iterator:GetEntitiesInArea", CFlowNode_GetEntitiesInArea);
  744. REGISTER_FLOW_NODE("Iterator:GetEntities", CFlowNode_GetEntities);
  745. REGISTER_FLOW_NODE("Iterator:GetEntitiesInBoxByClass", CFlowNode_GetEntitiesInBoxByClass);
  746.  
downloadFlowEntityIterator.cpp 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