BVB Source Codes

CRYENGINE Show FlowCustomActionNodes.cpp Source code

Return Download CRYENGINE: download FlowCustomActionNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   FlowCustomActionNodes.h
  6.    $Id$
  7.    Description: All nodes related to the Custom Action flow graphs
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 30:8:2011   15:24 : Created by Dean Claassen
  12.  
  13.  *********************************************************************/
  14.  
  15. #include "StdAfx.h"
  16.  
  17. #include "FlowCustomActionNodes.h"
  18.  
  19. #include "CustomActions/CustomAction.h"
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. // CustomAction:Start node.
  23. // This node is the start of the Custom Action
  24. //////////////////////////////////////////////////////////////////////////
  25. class CFlowNode_CustomActionStart : public CFlowBaseNode<eNCT_Singleton>
  26. {
  27. public:
  28.         CFlowNode_CustomActionStart(SActivationInfo* pActInfo)
  29.         {
  30.         }
  31.         virtual void GetConfiguration(SFlowNodeConfig& config)
  32.         {
  33.                 static const SInputPortConfig in_config[] =
  34.                 {
  35.                         { 0 }
  36.                 };
  37.                 static const SOutputPortConfig out_config[] =
  38.                 {
  39.                         OutputPortConfig<EntityId>("ObjectId", "Entity ID of the object on which the action is executing"),
  40.                         { 0 }
  41.                 };
  42.                 config.pInputPorts = 0; // in_config;
  43.                 config.pOutputPorts = out_config;
  44.                 config.sDescription = _HELP("This node is the start of the Custom Action");
  45.                 config.SetCategory(EFLN_APPROVED);
  46.         }
  47.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  48.         {
  49.                 ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction();
  50.  
  51.                 switch (event)
  52.                 {
  53.                 case eFE_Update:
  54.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  55.                         if (pCustomAction)
  56.                         {
  57.                                 IEntity* pTarget = pCustomAction->GetObjectEntity();
  58.                                 ActivateOutput(pActInfo, 0, pTarget ? pTarget->GetId() : 0);
  59.                         }
  60.                         break;
  61.                 case eFE_Initialize:
  62.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  63.                         break;
  64.                 case eFE_Activate:
  65.                         break;
  66.                 }
  67.         }
  68.  
  69.         virtual void GetMemoryUsage(ICrySizer* s) const
  70.         {
  71.                 s->Add(*this);
  72.         }
  73. };
  74.  
  75. //////////////////////////////////////////////////////////////////////////
  76. // CustomAction:Succeed node.
  77. // This node is the succeed path of the Custom Action
  78. //////////////////////////////////////////////////////////////////////////
  79. class CFlowNode_CustomActionSucceed : public CFlowBaseNode<eNCT_Singleton>
  80. {
  81. public:
  82.         CFlowNode_CustomActionSucceed(SActivationInfo* pActInfo)
  83.         {
  84.         }
  85.         virtual void GetConfiguration(SFlowNodeConfig& config)
  86.         {
  87.                 static const SInputPortConfig in_config[] =
  88.                 {
  89.                         { 0 }
  90.                 };
  91.                 static const SOutputPortConfig out_config[] =
  92.                 {
  93.                         OutputPortConfig<EntityId>("ObjectId", "Entity ID of the object on which the action is executing"),
  94.                         { 0 }
  95.                 };
  96.                 config.pInputPorts = 0; // in_config;
  97.                 config.pOutputPorts = out_config;
  98.                 config.sDescription = _HELP("This node is the succeed path of the Custom Action");
  99.                 config.SetCategory(EFLN_APPROVED);
  100.         }
  101.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  102.         {
  103.                 ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction();
  104.  
  105.                 switch (event)
  106.                 {
  107.                 case eFE_Update:
  108.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  109.                         if (pCustomAction)
  110.                         {
  111.                                 IEntity* pTarget = pCustomAction->GetObjectEntity();
  112.                                 ActivateOutput(pActInfo, 0, pTarget ? pTarget->GetId() : 0);
  113.                         }
  114.                         break;
  115.                 case eFE_Initialize:
  116.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  117.                         break;
  118.                 case eFE_Activate:
  119.                         break;
  120.                 }
  121.         }
  122.  
  123.         virtual void GetMemoryUsage(ICrySizer* s) const
  124.         {
  125.                 s->Add(*this);
  126.         }
  127. };
  128.  
  129. //////////////////////////////////////////////////////////////////////////
  130. // CustomAction:SucceedWait node.
  131. // This node is the succeed wait path of the Custom Action
  132. //////////////////////////////////////////////////////////////////////////
  133. class CFlowNode_CustomActionSucceedWait : public CFlowBaseNode<eNCT_Singleton>
  134. {
  135. public:
  136.         CFlowNode_CustomActionSucceedWait(SActivationInfo* pActInfo)
  137.         {
  138.         }
  139.         virtual void GetConfiguration(SFlowNodeConfig& config)
  140.         {
  141.                 static const SInputPortConfig in_config[] =
  142.                 {
  143.                         { 0 }
  144.                 };
  145.                 static const SOutputPortConfig out_config[] =
  146.                 {
  147.                         OutputPortConfig<EntityId>("ObjectId", "Entity ID of the object on which the action is executing"),
  148.                         { 0 }
  149.                 };
  150.                 config.pInputPorts = 0; // in_config;
  151.                 config.pOutputPorts = out_config;
  152.                 config.sDescription = _HELP("This node is the succeed wait path of the Custom Action");
  153.                 config.SetCategory(EFLN_APPROVED);
  154.         }
  155.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  156.         {
  157.                 ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction();
  158.  
  159.                 switch (event)
  160.                 {
  161.                 case eFE_Update:
  162.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  163.                         if (pCustomAction)
  164.                         {
  165.                                 IEntity* pTarget = pCustomAction->GetObjectEntity();
  166.                                 ActivateOutput(pActInfo, 0, pTarget ? pTarget->GetId() : 0);
  167.                         }
  168.                         break;
  169.                 case eFE_Initialize:
  170.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  171.                         break;
  172.                 case eFE_Activate:
  173.                         break;
  174.                 }
  175.         }
  176.  
  177.         virtual void GetMemoryUsage(ICrySizer* s) const
  178.         {
  179.                 s->Add(*this);
  180.         }
  181. };
  182.  
  183. //////////////////////////////////////////////////////////////////////////
  184. // CustomAction:SucceedWaitComplete node.
  185. // This node is the succeed wait complete path of the Custom Action
  186. //////////////////////////////////////////////////////////////////////////
  187. class CFlowNode_CustomActionSucceedWaitComplete : public CFlowBaseNode<eNCT_Singleton>
  188. {
  189. public:
  190.         CFlowNode_CustomActionSucceedWaitComplete(SActivationInfo* pActInfo)
  191.         {
  192.         }
  193.         virtual void GetConfiguration(SFlowNodeConfig& config)
  194.         {
  195.                 static const SInputPortConfig in_config[] =
  196.                 {
  197.                         { 0 }
  198.                 };
  199.                 static const SOutputPortConfig out_config[] =
  200.                 {
  201.                         OutputPortConfig<EntityId>("ObjectId", "Entity ID of the object on which the action is executing"),
  202.                         { 0 }
  203.                 };
  204.                 config.pInputPorts = 0; // in_config;
  205.                 config.pOutputPorts = out_config;
  206.                 config.sDescription = _HELP("This node is the succeed wait complete path of the Custom Action");
  207.                 config.SetCategory(EFLN_APPROVED);
  208.         }
  209.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  210.         {
  211.                 ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction();
  212.  
  213.                 switch (event)
  214.                 {
  215.                 case eFE_Update:
  216.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  217.                         if (pCustomAction)
  218.                         {
  219.                                 IEntity* pTarget = pCustomAction->GetObjectEntity();
  220.                                 ActivateOutput(pActInfo, 0, pTarget ? pTarget->GetId() : 0);
  221.                         }
  222.                         break;
  223.                 case eFE_Initialize:
  224.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  225.                         break;
  226.                 case eFE_Activate:
  227.                         break;
  228.                 }
  229.         }
  230.  
  231.         virtual void GetMemoryUsage(ICrySizer* s) const
  232.         {
  233.                 s->Add(*this);
  234.         }
  235. };
  236.  
  237. //////////////////////////////////////////////////////////////////////////
  238. // CustomAction:End node.
  239. // This node is the end point for all the paths in the Custom Action
  240. //////////////////////////////////////////////////////////////////////////
  241. class CFlowNode_CustomActionEnd : public CFlowBaseNode<eNCT_Singleton>
  242. {
  243. public:
  244.         CFlowNode_CustomActionEnd(SActivationInfo* pActInfo)
  245.         {
  246.         }
  247.         virtual void GetConfiguration(SFlowNodeConfig& config)
  248.         {
  249.                 static const SInputPortConfig in_config[] =
  250.                 {
  251.                         InputPortConfig_Void("Succeed",             _HELP("Start path ends here and succeed path begins")),
  252.                         InputPortConfig_Void("SucceedWait",         _HELP("Optional path that can be triggered after Succeed")),
  253.                         InputPortConfig_Void("SucceedWaitComplete", _HELP("Triggered when SucceedWait state is complete")),
  254.                         InputPortConfig_Void("Abort",               _HELP("Abort path begins")),
  255.                         InputPortConfig_Void("EndSuccess",          _HELP("Action ends in success")),
  256.                         InputPortConfig_Void("EndFailure",          _HELP("Action ends in failure")),
  257.                         { 0 }
  258.                 };
  259.                 config.nFlags |= EFLN_TARGET_ENTITY;
  260.                 config.pInputPorts = in_config;
  261.                 config.pOutputPorts = NULL;
  262.                 config.sDescription = _HELP("This node is the end point for all the paths in the Custom Action");
  263.                 config.SetCategory(EFLN_APPROVED);
  264.         }
  265.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  266.         {
  267.                 if (event != eFE_Activate)
  268.                         return;
  269.  
  270.                 ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction();
  271.                 if (!pCustomAction) // Not inside a custom graph, must be an instance hack, get associated entity
  272.                 {
  273.                         IEntity* pEntity = pActInfo->pEntity;
  274.                         if (!pEntity)
  275.                         {
  276.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CFlowNode_CustomActionEnd::ProcessEvent: Instance hack must have assigned entity");
  277.                                 return;
  278.                         }
  279.  
  280.                         ICustomActionManager* pCustomActionManager = gEnv->pGameFramework->GetICustomActionManager();
  281.                         if (pCustomActionManager)
  282.                         {
  283.                                 pCustomAction = pCustomActionManager->GetActiveCustomAction(pEntity);
  284.                                 if (!pCustomAction)
  285.                                 {
  286.                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CFlowNode_CustomActionEnd::ProcessEvent: Can't find custom action for entity");
  287.                                         return;
  288.                                 }
  289.                         }
  290.                 }
  291.  
  292.                 PREFAST_ASSUME(pCustomAction); // is validated above, if it fails it should already have returned
  293.  
  294.                 if (IsPortActive(pActInfo, 0))
  295.                         pCustomAction->SucceedAction();
  296.                 if (IsPortActive(pActInfo, 1))
  297.                         pCustomAction->SucceedWaitAction();
  298.                 if (IsPortActive(pActInfo, 2))
  299.                         pCustomAction->SucceedWaitCompleteAction();
  300.                 else if (IsPortActive(pActInfo, 3))
  301.                         pCustomAction->AbortAction();
  302.                 else if (IsPortActive(pActInfo, 4))
  303.                         pCustomAction->EndActionSuccess();
  304.                 else if (IsPortActive(pActInfo, 5))
  305.                         pCustomAction->EndActionFailure();
  306.         }
  307.  
  308.         virtual void GetMemoryUsage(ICrySizer* s) const
  309.         {
  310.                 s->Add(*this);
  311.         }
  312. };
  313.  
  314. //////////////////////////////////////////////////////////////////////////
  315. // CustomAction:Abort node.
  316. // This node starts the abort path for the Custom Action
  317. //////////////////////////////////////////////////////////////////////////
  318. class CFlowNode_CustomActionAbort : public CFlowBaseNode<eNCT_Instanced>
  319. {
  320. protected:
  321.         bool bAborted;
  322.  
  323. public:
  324.         CFlowNode_CustomActionAbort(SActivationInfo* pActInfo)
  325.         {
  326.                 bAborted = false;
  327.         }
  328.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  329.         {
  330.                 return new CFlowNode_CustomActionAbort(pActInfo);
  331.         }
  332.         void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  333.         {
  334.                 ser.Value("Aborted", bAborted);
  335.         }
  336.         virtual void GetConfiguration(SFlowNodeConfig& config)
  337.         {
  338.                 static const SInputPortConfig in_config[] =
  339.                 {
  340.                         { 0 }
  341.                 };
  342.                 static const SOutputPortConfig out_config[] =
  343.                 {
  344.                         OutputPortConfig<EntityId>("ObjectId", "Entity ID of the object on which the action is executing"),
  345.                         { 0 }
  346.                 };
  347.                 config.pInputPorts = in_config;
  348.                 config.pOutputPorts = out_config;
  349.                 config.sDescription = _HELP("This node starts the abort path for the Custom Action");
  350.                 config.SetCategory(EFLN_APPROVED);
  351.         }
  352.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  353.         {
  354.                 ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction();
  355.                 switch (event)
  356.                 {
  357.                 case eFE_Update:
  358.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  359.                         if (pCustomAction && !bAborted)
  360.                         {
  361.                                 // Abort only once
  362.                                 bAborted = true;
  363.  
  364.                                 IEntity* pTarget = pCustomAction->GetObjectEntity();
  365.                                 ActivateOutput(pActInfo, 0, pTarget ? pTarget->GetId() : 0);
  366.                         }
  367.                         break;
  368.                 case eFE_Initialize:
  369.                         bAborted = false;
  370.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  371.                         break;
  372.                 case eFE_Activate:
  373.                         if (!bAborted && pCustomAction && IsPortActive(pActInfo, 0))
  374.                         {
  375.                                 pCustomAction->AbortAction();
  376.                         }
  377.                         break;
  378.                 }
  379.         }
  380.  
  381.         virtual void GetMemoryUsage(ICrySizer* s) const
  382.         {
  383.                 s->Add(*this);
  384.         }
  385. };
  386.  
  387. //////////////////////////////////////////////////////////////////////////
  388. // CustomAction:Control node.
  389. // This node is used to control a custom action from a specific instance
  390. //////////////////////////////////////////////////////////////////////////
  391. CFlowNode_CustomActionControl::~CFlowNode_CustomActionControl()
  392. {
  393.         ICustomActionManager* pCustomActionManager = gEnv->pGameFramework->GetICustomActionManager();
  394.         if (pCustomActionManager)
  395.         {
  396.                 pCustomActionManager->UnregisterListener(this);
  397.         }
  398. }
  399.  
  400. void CFlowNode_CustomActionControl::GetConfiguration(SFlowNodeConfig& config)
  401. {
  402.         static const SInputPortConfig in_ports[] =
  403.         {
  404.                 InputPortConfig<string>("Start",               _HELP("Enters the start path")),
  405.                 InputPortConfig<string>("Succeed",             _HELP("Enters the succeed path")),
  406.                 InputPortConfig<string>("SucceedWait",         _HELP("Enters the succeed wait path (Optional from Succeed instead of EndSuccess)")),
  407.                 InputPortConfig<string>("SucceedWaitComplete", _HELP("Enters the succeed wait complete path (After SucceedWait which connects to EndSuccess)")),
  408.                 InputPortConfig_Void("Abort",                  _HELP("Enters the abort path")),
  409.                 InputPortConfig_Void("EndSuccess",             _HELP("Ends in success")),
  410.                 InputPortConfig_Void("EndFailure",             _HELP("Ends in failure")),
  411.                 { 0 }
  412.         };
  413.  
  414.         static const SOutputPortConfig out_ports[] =
  415.         {
  416.                 OutputPortConfig_Void("Started",             _HELP("Entered the start path")),
  417.                 OutputPortConfig_Void("Succeeded",           _HELP("Entered the succeed path")),
  418.                 OutputPortConfig_Void("SucceedWait",         _HELP("Enters the succeed wait path (Optional from Succeed instead of EndSuccess)")),
  419.                 OutputPortConfig_Void("SucceedWaitComplete", _HELP("Enters the succeed wait complete path (After SucceedWait which connects to EndSuccess)")),
  420.                 OutputPortConfig_Void("Aborted",             _HELP("Entered the abort path")),
  421.                 OutputPortConfig_Void("EndedSuccess",        _HELP("Ends in success")),
  422.                 OutputPortConfig_Void("EndedFailure",        _HELP("Ends in failure")),
  423.                 { 0 }
  424.         };
  425.  
  426.         config.nFlags |= EFLN_TARGET_ENTITY;
  427.         config.pInputPorts = in_ports;
  428.         config.pOutputPorts = out_ports;
  429.         config.sDescription = _HELP("Node is used to control a specific custom action instance");
  430.         config.SetCategory(EFLN_APPROVED);
  431. }
  432.  
  433. void CFlowNode_CustomActionControl::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  434. {
  435.         if (event == eFE_Activate)
  436.         {
  437.                 IEntity* pEntity = pActInfo->pEntity;
  438.                 if (!pEntity)
  439.                         return;
  440.  
  441.                 ICustomActionManager* pCustomActionManager = gEnv->pGameFramework->GetICustomActionManager();
  442.                 CRY_ASSERT(pCustomActionManager != NULL);
  443.                 if (!pCustomActionManager)
  444.                         return;
  445.  
  446.                 if (IsPortActive(pActInfo, EIP_Start))
  447.                 {
  448.                         const string& customGraphName = GetPortString(pActInfo, EIP_Start);
  449.  
  450.                         pCustomActionManager->StartAction(pEntity, customGraphName.c_str(), this);
  451.  
  452.                         // Output port is activated from event
  453.                 }
  454.                 else if (IsPortActive(pActInfo, EIP_Succeed))
  455.                 {
  456.                         const string& customGraphName = GetPortString(pActInfo, EIP_Succeed);
  457.  
  458.                         pCustomActionManager->SucceedAction(pEntity, customGraphName.c_str(), this);
  459.  
  460.                         // Output port is activated from event
  461.                 }
  462.                 else if (IsPortActive(pActInfo, EIP_SucceedWait))
  463.                 {
  464.                         pCustomActionManager->SucceedWaitAction(pEntity);
  465.  
  466.                         // Output port is activated from event
  467.                 }
  468.                 else if (IsPortActive(pActInfo, EIP_SucceedWaitComplete))
  469.                 {
  470.                         pCustomActionManager->SucceedWaitCompleteAction(pEntity);
  471.                         // Output port is activated from event
  472.                 }
  473.                 else if (IsPortActive(pActInfo, EIP_Abort))
  474.                 {
  475.                         pCustomActionManager->AbortAction(pEntity);
  476.  
  477.                         // Output port is activated from event
  478.                 }
  479.                 else if (IsPortActive(pActInfo, EIP_EndSuccess))
  480.                 {
  481.                         ICustomAction* pCustomAction = pCustomActionManager->GetActiveCustomAction(pEntity);
  482.                         if (!pCustomAction)
  483.                         {
  484.                                 return;
  485.                         }
  486.  
  487.                         pCustomAction->EndActionSuccess();
  488.  
  489.                         // Output port is activated from event
  490.                 }
  491.                 else if (IsPortActive(pActInfo, EIP_EndFailure))
  492.                 {
  493.                         ICustomAction* pCustomAction = pCustomActionManager->GetActiveCustomAction(pEntity);
  494.                         if (!pCustomAction)
  495.                         {
  496.                                 return;
  497.                         }
  498.  
  499.                         pCustomAction->EndActionFailure();
  500.  
  501.                         // Output port is activated from event
  502.                 }
  503.         }
  504.         else if (event == eFE_SetEntityId)
  505.         {
  506.                 m_actInfo = *pActInfo;
  507.         }
  508. }
  509.  
  510. void CFlowNode_CustomActionControl::OnCustomActionEvent(ECustomActionEvent event, ICustomAction& customAction)
  511. {
  512.         IEntity* pEntity = customAction.GetObjectEntity();
  513.         if (!pEntity)
  514.                 return;
  515.  
  516.         if (pEntity != m_actInfo.pEntity) // Events are received for all entities
  517.                 return;
  518.  
  519.         switch (event)
  520.         {
  521.         case CAE_Started:
  522.                 {
  523.                         ActivateOutput(&m_actInfo, EOP_Started, true);
  524.                 }
  525.                 break;
  526.         case CAE_Succeeded:
  527.                 {
  528.                         ActivateOutput(&m_actInfo, EOP_Succeeded, true);
  529.                 }
  530.                 break;
  531.         case CAE_SucceededWait:
  532.                 {
  533.                         ActivateOutput(&m_actInfo, EOP_SucceededWait, true);
  534.                 }
  535.                 break;
  536.         case CAE_SucceededWaitComplete:
  537.                 {
  538.                         ActivateOutput(&m_actInfo, EOP_SucceededWaitComplete, true);
  539.                 }
  540.                 break;
  541.         case CAE_Aborted:
  542.                 {
  543.                         ActivateOutput(&m_actInfo, EOP_Aborted, true);
  544.                 }
  545.                 break;
  546.         case CAE_EndedSuccess:
  547.                 {
  548.                         ActivateOutput(&m_actInfo, EOP_EndedSuccess, true);
  549.                 }
  550.                 break;
  551.         case CAE_EndedFailure:
  552.                 {
  553.                         ActivateOutput(&m_actInfo, EOP_EndedFailure, true);
  554.                 }
  555.                 break;
  556.         }
  557. }
  558.  
  559. REGISTER_FLOW_NODE("CustomAction:Start", CFlowNode_CustomActionStart)
  560. REGISTER_FLOW_NODE("CustomAction:Succeed", CFlowNode_CustomActionSucceed)
  561. REGISTER_FLOW_NODE("CustomAction:SucceedWait", CFlowNode_CustomActionSucceedWait)
  562. REGISTER_FLOW_NODE("CustomAction:SucceedWaitComplete", CFlowNode_CustomActionSucceedWaitComplete)
  563. REGISTER_FLOW_NODE("CustomAction:End", CFlowNode_CustomActionEnd)
  564. REGISTER_FLOW_NODE("CustomAction:Abort", CFlowNode_CustomActionAbort)
  565. REGISTER_FLOW_NODE("CustomAction:Control", CFlowNode_CustomActionControl)
  566.  
downloadFlowCustomActionNodes.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