BVB Source Codes

CRYENGINE Show FlowContainerNode.cpp Source code

Return Download CRYENGINE: download FlowContainerNode.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.  
  7. ////////////////////////////////////////////////////////////////////////////////////////
  8. class CFlowCreateContainerNode : public CFlowBaseNode<eNCT_Instanced>
  9. {
  10. private:
  11.         enum
  12.         {
  13.                 EIP_Id,
  14.                 EIP_Create,
  15.         };
  16.  
  17.         enum
  18.         {
  19.                 EOP_Error,
  20.                 EOP_Success,
  21.                 EOP_Id,
  22.         };
  23.  
  24. public:
  25.         CFlowCreateContainerNode(SActivationInfo* pActInfo)
  26.         {
  27.  
  28.         }
  29.  
  30.         virtual ~CFlowCreateContainerNode()
  31.         {
  32.  
  33.         }
  34.  
  35.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  36.         {
  37.                 return new CFlowCreateContainerNode(pActInfo);
  38.         }
  39.  
  40.         virtual void GetConfiguration(SFlowNodeConfig& config)
  41.         {
  42.                 static const SInputPortConfig inputs[] = {
  43.                         InputPortConfig<int>("Id",     0,                            _HELP("Id for the container")),
  44.                         InputPortConfig_Void("Create", _HELP("Create a container")),
  45.                         { 0 }
  46.                 };
  47.  
  48.                 static const SOutputPortConfig outputs[] = {
  49.                         OutputPortConfig<int>("Error",      _HELP("the number specifies the error - 1: Container already exists")),
  50.                         OutputPortConfig_AnyType("Success", _HELP("Operation successfully completed")),
  51.                         OutputPortConfig<int>("Id",         _HELP("Id of the container if successfully created")),
  52.                         { 0 }
  53.                 };
  54.  
  55.                 config.sDescription = _HELP("This node is used to create containers");
  56.                 config.pInputPorts = inputs;
  57.                 config.pOutputPorts = outputs;
  58.                 config.SetCategory(EFLN_APPROVED);
  59.         }
  60.  
  61.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  62.         {
  63.                 switch (event)
  64.                 {
  65.                 case eFE_Activate:
  66.                         {
  67.                                 if (IsPortActive(pActInfo, EIP_Create))
  68.                                 {
  69.                                         int id = GetPortInt(pActInfo, EIP_Id);
  70.                                         if (gEnv->pFlowSystem->CreateContainer(id))
  71.                                         {
  72.                                                 ActivateOutput(pActInfo, EOP_Id, id);
  73.                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  74.                                         }
  75.                                         else
  76.                                         {
  77.                                                 ActivateOutput(pActInfo, EOP_Error, 1);
  78.                                         }
  79.                                 }
  80.                         }
  81.                         break;
  82.                 }
  83.         }
  84.  
  85.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  86.         {
  87.  
  88.         }
  89.  
  90.         virtual void GetMemoryUsage(ICrySizer* s) const
  91.         {
  92.                 s->Add(*this);
  93.         }
  94. };
  95.  
  96. ////////////////////////////////////////////////////////////////////////////////////////
  97. class CFlowEditContainerNode : public CFlowBaseNode<eNCT_Instanced>
  98. {
  99. private:
  100.         enum
  101.         {
  102.                 EIP_Id,
  103.                 EIP_Add,
  104.                 EIP_AddUnique,
  105.                 EIP_Remove,
  106.                 EIP_Clear,
  107.                 EIP_GetCount,
  108.                 EIP_Delete,
  109.         };
  110.  
  111.         enum
  112.         {
  113.                 EOP_Error,
  114.                 EOP_Success,
  115.         };
  116.  
  117. public:
  118.         CFlowEditContainerNode(SActivationInfo* pActInfo)
  119.         {
  120.  
  121.         }
  122.  
  123.         virtual ~CFlowEditContainerNode()
  124.         {
  125.  
  126.         }
  127.  
  128.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  129.         {
  130.                 return new CFlowEditContainerNode(pActInfo);
  131.         }
  132.  
  133.         virtual void GetConfiguration(SFlowNodeConfig& config)
  134.         {
  135.                 static const SInputPortConfig inputs[] = {
  136.                         InputPortConfig<int>("Id",           _HELP("Which container to manipulate")),
  137.                         InputPortConfig_AnyType("Add",       _HELP("Add the passed item")),
  138.                         InputPortConfig_AnyType("AddUnique", _HELP("Add the passed item if it didnt exist")),
  139.                         InputPortConfig_AnyType("Remove",    _HELP("Remove all occurrences of the current item")),
  140.                         InputPortConfig_AnyType("Clear",     _HELP("Empty container")),
  141.                         InputPortConfig_Void("GetCount",     _HELP("Get number of elements - result send in success port if containerId was valid")),
  142.                         InputPortConfig_Void("Delete",       _HELP("Delete container")),
  143.                         { 0 }
  144.                 };
  145.  
  146.                 static const SOutputPortConfig outputs[] = {
  147.                         OutputPortConfig<int>("Error",      _HELP("the number specifies the error - 1: Container ID is invalid")),
  148.                         OutputPortConfig_AnyType("Success", _HELP("Operation successfully completed")),
  149.                         { 0 }
  150.                 };
  151.  
  152.                 config.sDescription = _HELP("This node is used to access and manipulate containers");
  153.                 config.pInputPorts = inputs;
  154.                 config.pOutputPorts = outputs;
  155.                 config.SetCategory(EFLN_APPROVED);
  156.         }
  157.  
  158.         IFlowSystemContainerPtr GetContainer(SActivationInfo* pActInfo)
  159.         {
  160.                 TFlowSystemContainerId id = GetPortInt(pActInfo, EIP_Id);
  161.                 IFlowSystemContainerPtr container = gEnv->pFlowSystem->GetContainer(id);
  162.                 TFlowInputData data = GetPortAny(pActInfo, EIP_Add);
  163.                 if (container)
  164.                 {
  165.                         return container;
  166.                 }
  167.                 else
  168.                 {
  169.                         ActivateOutput(pActInfo, EOP_Error, 1); // Container doesn't exist
  170.                         return IFlowSystemContainerPtr();
  171.                 }
  172.         }
  173.  
  174.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  175.         {
  176.                 switch (event)
  177.                 {
  178.                 case eFE_Activate:
  179.                         {
  180.                                 if (IsPortActive(pActInfo, EIP_Add))
  181.                                 {
  182.                                         if (IFlowSystemContainerPtr container = GetContainer(pActInfo))
  183.                                         {
  184.                                                 TFlowInputData data = GetPortAny(pActInfo, EIP_Add);
  185.                                                 container->AddItem(data);
  186.                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  187.                                         }
  188.                                 }
  189.  
  190.                                 if (IsPortActive(pActInfo, EIP_AddUnique))
  191.                                 {
  192.                                         if (IFlowSystemContainerPtr container = GetContainer(pActInfo))
  193.                                         {
  194.                                                 container->AddItemUnique(GetPortAny(pActInfo, EIP_AddUnique));
  195.                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  196.                                         }
  197.                                 }
  198.  
  199.                                 if (IsPortActive(pActInfo, EIP_Remove))
  200.                                 {
  201.                                         if (IFlowSystemContainerPtr container = GetContainer(pActInfo))
  202.                                         {
  203.                                                 container->RemoveItem(GetPortAny(pActInfo, EIP_Remove));
  204.                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  205.                                         }
  206.                                 }
  207.  
  208.                                 if (IsPortActive(pActInfo, EIP_Clear))
  209.                                 {
  210.                                         if (IFlowSystemContainerPtr container = GetContainer(pActInfo))
  211.                                         {
  212.                                                 container->Clear();
  213.                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  214.                                         }
  215.                                 }
  216.  
  217.                                 if (IsPortActive(pActInfo, EIP_GetCount))
  218.                                 {
  219.                                         if (IFlowSystemContainerPtr container = GetContainer(pActInfo))
  220.                                         {
  221.                                                 ActivateOutput(pActInfo, EOP_Success, container->GetItemCount());
  222.                                         }
  223.                                 }
  224.  
  225.                                 if (IsPortActive(pActInfo, EIP_Delete))
  226.                                 {
  227.                                         if (IFlowSystemContainerPtr container = GetContainer(pActInfo))
  228.                                         {
  229.                                                 gEnv->pFlowSystem->DeleteContainer(GetPortInt(pActInfo, EIP_Id));
  230.                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  231.                                         }
  232.                                 }
  233.                         }
  234.                         break;
  235.                 }
  236.         }
  237.  
  238.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  239.         {
  240.  
  241.         }
  242.  
  243.         virtual void GetMemoryUsage(ICrySizer* s) const
  244.         {
  245.                 s->Add(*this);
  246.         }
  247. };
  248.  
  249. ////////////////////////////////////////////////////////////////////////////////////////
  250. class CFlowIterateContainerNode : public CFlowBaseNode<eNCT_Instanced>
  251. {
  252. private:
  253.         TFlowSystemContainerId m_containerId;
  254.         int                    m_currentIdx;
  255.  
  256.         enum
  257.         {
  258.                 EIP_Id,
  259.                 EIP_Start,
  260.         };
  261.  
  262.         enum
  263.         {
  264.                 EOP_Error,
  265.                 EOP_Done,
  266.                 EOP_Out,
  267.         };
  268.  
  269. public:
  270.         CFlowIterateContainerNode(SActivationInfo* pActInfo)
  271.         {
  272.                 m_containerId = InvalidContainerId;
  273.                 m_currentIdx = 0;
  274.         }
  275.  
  276.         virtual ~CFlowIterateContainerNode()
  277.         {
  278.  
  279.         }
  280.  
  281.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  282.         {
  283.                 return new CFlowIterateContainerNode(pActInfo);
  284.         }
  285.  
  286.         virtual void GetConfiguration(SFlowNodeConfig& config)
  287.         {
  288.                 static const SInputPortConfig inputs[] = {
  289.                         InputPortConfig<int>("Id",    0,                         _HELP("Id for the container")),
  290.                         InputPortConfig_Void("Start", _HELP("Start iterating")),
  291.                         { 0 }
  292.                 };
  293.  
  294.                 static const SOutputPortConfig outputs[] = {
  295.                         OutputPortConfig<int>("Error",  _HELP("the number specifies the error - 1: containerId is invalid")),
  296.                         OutputPortConfig_Void("Done",   _HELP("Operation successfully completed")),
  297.                         OutputPortConfig_AnyType("Out", _HELP("Value from the container")),
  298.                         { 0 }
  299.                 };
  300.  
  301.                 config.sDescription = _HELP("This node is used to iterator over containers");
  302.                 config.pInputPorts = inputs;
  303.                 config.pOutputPorts = outputs;
  304.                 config.SetCategory(EFLN_APPROVED);
  305.         }
  306.  
  307.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  308.         {
  309.                 switch (event)
  310.                 {
  311.                 case eFE_Activate:
  312.                         {
  313.                                 if (IsPortActive(pActInfo, EIP_Start))
  314.                                 {
  315.                                         m_currentIdx = 0;
  316.                                         m_containerId = GetPortInt(pActInfo, EIP_Id);
  317.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  318.                                 }
  319.                         }
  320.                         break;
  321.                 case eFE_Update:
  322.                         {
  323.                                 IFlowSystemContainerPtr pContainer = gEnv->pFlowSystem->GetContainer(m_containerId);
  324.                                 if (pContainer)
  325.                                 {
  326.                                         if (m_currentIdx < pContainer->GetItemCount())
  327.                                         {
  328.                                                 ActivateOutput(pActInfo, EOP_Out, pContainer->GetItem(m_currentIdx));
  329.                                                 m_currentIdx++;
  330.                                         }
  331.                                         else
  332.                                         {
  333.                                                 ActivateOutput(pActInfo, EOP_Done, 1);
  334.                                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  335.                                         }
  336.                                 }
  337.                                 else
  338.                                 {
  339.                                         ActivateOutput(pActInfo, EOP_Error, 1);
  340.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  341.                                 }
  342.                         }
  343.  
  344.                         break;
  345.                 }
  346.         }
  347.  
  348.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  349.         {
  350.  
  351.         }
  352.  
  353.         virtual void GetMemoryUsage(ICrySizer* s) const
  354.         {
  355.                 s->Add(*this);
  356.         }
  357. };
  358.  
  359. REGISTER_FLOW_NODE("System:Container:Create", CFlowCreateContainerNode);
  360. REGISTER_FLOW_NODE("System:Container:Edit", CFlowEditContainerNode);
  361. REGISTER_FLOW_NODE("System:Container:Iterate", CFlowIterateContainerNode);
  362.  
downloadFlowContainerNode.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