BVB Source Codes

CRYENGINE Show FlowCompositeNode.cpp Source code

Return Download CRYENGINE: download FlowCompositeNode.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. #include "FlowCompositeNode.h"
  5. #include "../FlowSerialize.h"
  6.  
  7. using namespace NFlowCompositeHelpers;
  8.  
  9. static const char* INTERIOR_NODE_TYPE = "CompositeInterior";
  10.  
  11. /*
  12.  * inner-node
  13.  */
  14.  
  15. CCompositeInteriorNode::CCompositeInteriorNode(CFlowCompositeNodeFactoryPtr pFactory)
  16.         : m_refs(0)
  17.         , m_pFactory(pFactory)
  18.         , m_pParent(nullptr)
  19. {
  20. }
  21.  
  22. void CCompositeInteriorNode::AddRef()
  23. {
  24.         ++m_refs;
  25. }
  26.  
  27. void CCompositeInteriorNode::Release()
  28. {
  29.         if (0 == --m_refs)
  30.                 delete this;
  31. }
  32.  
  33. IFlowNodePtr CCompositeInteriorNode::Clone(SActivationInfo*)
  34. {
  35.         return this;
  36. }
  37.  
  38. void CCompositeInteriorNode::GetConfiguration(SFlowNodeConfig& config)
  39. {
  40.         m_pFactory->GetConfiguration(false, config);
  41. }
  42.  
  43. void CCompositeInteriorNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  44. {
  45.         switch (event)
  46.         {
  47.         case eFE_Activate:
  48.                 {
  49.                         size_t numPorts = m_pFactory->GetInputPortCount(false);
  50.                         TFlowNodeId interfaceNode = m_pFactory->GetInterfaceNode();
  51.                         CCompositeGraph* pMyGraph = (CCompositeGraph*) pActInfo->pGraph;
  52.                         pActInfo = pMyGraph->GetParentInfo();
  53.  
  54.                         for (size_t i = 0; i < numPorts; i++)
  55.                         {
  56.                                 if (pActInfo->pInputPorts[i].IsUserFlagSet())
  57.                                         pActInfo->pGraph->ActivatePort(SFlowAddress(pActInfo->myID, static_cast<TFlowPortId>(i), true), pActInfo->pInputPorts[i]);
  58.                         }
  59.                 }
  60.                 break;
  61.         }
  62. }
  63.  
  64. bool CCompositeInteriorNode::SerializeXML(SActivationInfo*, const XmlNodeRef& root, bool reading)
  65. {
  66.         return true;
  67. }
  68.  
  69. void CCompositeInteriorNode::Serialize(SActivationInfo*, TSerialize ser)
  70. {
  71. }
  72.  
  73. void CCompositeInteriorNode::GetMemoryUsage(ICrySizer* s) const
  74. {
  75.         s->Add(*this);
  76. }
  77.  
  78. /*
  79.  * hook
  80.  */
  81.  
  82. CHook::CHook(CFlowSystem* pFlowSystem, CFlowCompositeNodeFactoryPtr pFactory)
  83.         : m_refs(0), m_pFlowSystem(pFlowSystem), m_pFactory(pFactory), m_id(InvalidFlowNodeId), m_bFail(false)
  84. {
  85. }
  86.  
  87. void CHook::Release()
  88. {
  89.         if (0 == --m_refs)
  90.                 delete this;
  91. }
  92.  
  93. void CHook::AddRef()
  94. {
  95.         ++m_refs;
  96. }
  97.  
  98. IFlowNodePtr CHook::CreateNode(IFlowNode::SActivationInfo*, TFlowNodeTypeId typeId)
  99. {
  100.         if (!strcmp(INTERIOR_NODE_TYPE, m_pFlowSystem->GetTypeName(typeId)))
  101.                 return new CCompositeInteriorNode(m_pFactory);
  102.         return IFlowNodePtr();
  103. }
  104.  
  105. bool CHook::CreatedNode(TFlowNodeId id, const char* name, TFlowNodeTypeId typeId, IFlowNodePtr pNode)
  106. {
  107.         if (!strcmp(INTERIOR_NODE_TYPE, m_pFlowSystem->GetTypeName(typeId)))
  108.         {
  109.                 if (m_id != InvalidFlowNodeId)
  110.                         m_bFail = true;
  111.                 else
  112.                         m_id = id;
  113.         }
  114.         return !m_bFail;
  115. }
  116.  
  117. void CHook::CancelCreatedNode(TFlowNodeId id, const char* name, TFlowNodeTypeId typeId, IFlowNodePtr pNode)
  118. {
  119.         if (id == m_id)
  120.         {
  121.                 m_id = InvalidFlowNodeId;
  122.                 m_bFail = true;
  123.         }
  124. }
  125.  
  126. /*
  127.  * graph
  128.  */
  129.  
  130. CCompositeGraph::CCompositeGraph(CFlowSystem* pSys) : CFlowGraph(pSys), m_pParent(NULL)
  131. {
  132. }
  133.  
  134. IFlowGraphPtr CCompositeGraph::Clone()
  135. {
  136.         CCompositeGraph* pClone = new CCompositeGraph(GetSys());
  137.         CloneInner(pClone);
  138.         return pClone;
  139. }
  140.  
  141. IFlowNode::SActivationInfo* CCompositeGraph::GetParentInfo()
  142. {
  143.         return m_pParent->GetParentInfo();
  144. }
  145.  
  146. void CCompositeGraph::GetMemoryUsage(ICrySizer* s) const
  147. {
  148.         s->Add(*this);
  149.         CFlowGraph::GetMemoryUsage(s);
  150. }
  151.  
  152. /*
  153.  * node
  154.  */
  155.  
  156. CFlowCompositeNode::CFlowCompositeNode(SActivationInfo* pActInfo, IFlowGraphPtr pGraph, CFlowCompositeNodeFactoryPtr pFactory)
  157.         : m_refs(0), m_parentInfo(*pActInfo), m_pGraph(pGraph), m_pFactory(pFactory)
  158. {
  159.         ((CCompositeGraph*)&*pGraph)->Reparent(this);
  160.         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  161. }
  162.  
  163. void CFlowCompositeNode::AddRef()
  164. {
  165.         ++m_refs;
  166. }
  167.  
  168. void CFlowCompositeNode::Release()
  169. {
  170.         if (0 == --m_refs)
  171.                 delete this;
  172. }
  173.  
  174. IFlowNodePtr CFlowCompositeNode::Clone(SActivationInfo* pActInfo)
  175. {
  176.         CFlowCompositeNode* out = new CFlowCompositeNode(pActInfo, m_pGraph->Clone(), m_pFactory);
  177.         return out;
  178. }
  179.  
  180. void CFlowCompositeNode::GetConfiguration(SFlowNodeConfig& config)
  181. {
  182.         m_pFactory->GetConfiguration(true, config);
  183. }
  184.  
  185. void CFlowCompositeNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  186. {
  187.         switch (event)
  188.         {
  189.         case eFE_Update:
  190.                 m_pGraph->Update();
  191.                 break;
  192.         case eFE_Activate:
  193.         case eFE_Initialize:
  194.                 {
  195.                         size_t numPorts = m_pFactory->GetInputPortCount(true);
  196.                         TFlowNodeId interfaceNode = m_pFactory->GetInterfaceNode();
  197.  
  198.                         for (size_t i = 0; i < numPorts; i++)
  199.                         {
  200.                                 if (pActInfo->pInputPorts[i].IsUserFlagSet())
  201.                                         m_pGraph->ActivatePort(SFlowAddress(interfaceNode, static_cast<TFlowPortId>(i), true), pActInfo->pInputPorts[i]);
  202.                         }
  203.                 }
  204.                 break;
  205.         }
  206. }
  207.  
  208. bool CFlowCompositeNode::SerializeXML(SActivationInfo*, const XmlNodeRef& root, bool reading)
  209. {
  210.         return false;
  211. }
  212.  
  213. void CFlowCompositeNode::Serialize(SActivationInfo*, TSerialize ser)
  214. {
  215.         ser.BeginGroup("ChildGraph");
  216.         m_pGraph->Serialize(ser);
  217.         ser.EndGroup();
  218. }
  219.  
  220. void CFlowCompositeNode::GetMemoryUsage(ICrySizer* s) const
  221. {
  222.         s->Add(*this);
  223.         m_pGraph->GetMemoryUsage(s);
  224. }
  225.  
  226. /*
  227.  * factory
  228.  */
  229.  
  230. CFlowCompositeNodeFactory::CFlowCompositeNodeFactory() :
  231.         m_nRefs(0)
  232. {
  233. }
  234.  
  235. CFlowCompositeNodeFactory::~CFlowCompositeNodeFactory()
  236. {
  237. }
  238.  
  239. CFlowCompositeNodeFactory::EInitResult CFlowCompositeNodeFactory::Init(XmlNodeRef node, CFlowSystem* pSystem)
  240. {
  241.         XmlNodeRef ports = node->findChild("Ports");
  242.         if (!ports)
  243.         {
  244.                 GameWarning("[flow] Composite %s has no ports", node->getAttr("name"));
  245.                 return eIR_Failed;
  246.         }
  247.  
  248.         int nPorts = ports->getChildCount();
  249.         for (int i = 0; i < nPorts; i++)
  250.         {
  251.                 XmlNodeRef port = ports->getChild(i);
  252.                 if (!port)
  253.                 {
  254.                         GameWarning("[flow] Composite %s has no port %d", node->getAttr("name"), i);
  255.                         return eIR_Failed;
  256.                 }
  257.  
  258.                 const char* tag = port->getTag();
  259.                 TPortPairPtr pPorts = GeneratePortsFromXML(port);
  260.                 if (!pPorts.get())
  261.                 {
  262.                         GameWarning("[flow] Composite %s cannot generate port %d", node->getAttr("name"), i);
  263.                         return eIR_Failed;
  264.                 }
  265.  
  266.                 if (0 == strcmp("Input", tag))
  267.                 {
  268.                         m_inputsExt.push_back(pPorts->first);
  269.                         m_outputsInt.push_back(pPorts->second);
  270.                 }
  271.                 else if (0 == strcmp("Output", tag))
  272.                 {
  273.                         m_inputsInt.push_back(pPorts->first);
  274.                         m_outputsExt.push_back(pPorts->second);
  275.                 }
  276.                 else
  277.                 {
  278.                         GameWarning("[flow] Composite %s - no such port type %s (on port %d)", node->getAttr("name"), tag, i);
  279.                         return eIR_Failed;
  280.                 }
  281.         }
  282.  
  283.         SOutputPortConfig termOut = { 0 };
  284.         m_outputsInt.push_back(termOut);
  285.         m_outputsExt.push_back(termOut);
  286.         SInputPortConfig termIn = { 0 };
  287.         m_inputsInt.push_back(termIn);
  288.         m_inputsExt.push_back(termIn);
  289.  
  290.         CRY_ASSERT(m_nRefs);
  291.         CHookPtr pHook = new CHook(pSystem, this);
  292.         m_pPrototypeGraph = new CCompositeGraph(pSystem);
  293.         m_pPrototypeGraph->RegisterHook(&*pHook);
  294.         if (!m_pPrototypeGraph->SerializeXML(node, true))
  295.                 return eIR_NotYet;
  296.         m_interfaceNode = pHook->GetID();
  297.         m_pPrototypeGraph->UnregisterHook(&*pHook);
  298.         if (m_interfaceNode == InvalidFlowNodeId)
  299.         {
  300.                 GameWarning("[flow] Composite %s has no %s node", node->getAttr("name"), INTERIOR_NODE_TYPE);
  301.                 return eIR_Failed;
  302.         }
  303.  
  304.         return eIR_Ok;
  305. }
  306.  
  307. void CFlowCompositeNodeFactory::GetConfiguration(bool exterior, SFlowNodeConfig& config)
  308. {
  309.         if (exterior)
  310.         {
  311.                 config.pInputPorts = &m_inputsExt[0];
  312.                 config.pOutputPorts = &m_outputsExt[0];
  313.         }
  314.         else
  315.         {
  316.                 config.pInputPorts = &m_inputsInt[0];
  317.                 config.pOutputPorts = &m_outputsInt[0];
  318.         }
  319. }
  320.  
  321. void CFlowCompositeNodeFactory::AddRef()
  322. {
  323.         ++m_nRefs;
  324. }
  325.  
  326. void CFlowCompositeNodeFactory::Release()
  327. {
  328.         if (0 == --m_nRefs)
  329.                 delete this;
  330. }
  331.  
  332. IFlowNodePtr CFlowCompositeNodeFactory::Create(IFlowNode::SActivationInfo* pActInfo)
  333. {
  334.         return new CFlowCompositeNode(pActInfo, m_pPrototypeGraph->Clone(), this);
  335. }
  336.  
  337. const string& CFlowCompositeNodeFactory::AddString(const char* str)
  338. {
  339.         m_stringPool.push_back(str);
  340.         return m_stringPool.back();
  341. }
  342.  
  343. CFlowCompositeNodeFactory::TPortPairPtr CFlowCompositeNodeFactory::GeneratePortsFromXML(XmlNodeRef port)
  344. {
  345.         TPortPairPtr result(new TPortPair);
  346.  
  347.         const char* c_name = port->getAttr("name");
  348.         if (!c_name || !c_name[0])
  349.         {
  350.                 GameWarning("[flow] Composite: Port has no name!");
  351.                 return TPortPairPtr();
  352.         }
  353.         const string& name = AddString(c_name);
  354.  
  355.         int type = -1;
  356.         if (port->getAttr("type", type))
  357.         {
  358.                 if (type != -1)
  359.                 {
  360.                         if (!result->first.defaultData.SetDefaultForTag(type))
  361.                         {
  362.                                 GameWarning("[flow] Composite: No node type %d", type);
  363.                                 return TPortPairPtr();
  364.                         }
  365.                         result->first.defaultData.SetLocked();
  366.                         if (!SetFromString(result->first.defaultData, port->getAttr("value")))
  367.                         {
  368.                                 GameWarning("[flow] Composite: Data '%s' is invalid for type %d", port->getAttr("value"), type);
  369.                                 return TPortPairPtr();
  370.                         }
  371.                 }
  372.         }
  373.         if (type == -1)
  374.                 result->first.defaultData.SetUnlocked();
  375.         result->second.type = type;
  376.         result->first.name = result->second.name = name.c_str();
  377.  
  378.         return result;
  379. }
  380.  
  381. void CFlowCompositeNodeFactory::GetMemoryUsage(ICrySizer* s) const
  382. {
  383.         SIZER_SUBCOMPONENT_NAME(s, "CFlowCompositeNodeFactory");
  384.         s->Add(*this);
  385.         s->AddObject(m_stringPool);
  386.         s->AddObject(m_inputsInt);
  387.         s->AddObject(m_inputsExt);
  388.         s->AddObject(m_outputsInt);
  389.         s->AddObject(m_outputsExt);
  390. }
  391.  
  392. //////////////////////////////////////////////////////////////////////////
  393. class CFlowNode_Composite_Input : public CFlowBaseNode<eNCT_Singleton>
  394. {
  395. public:
  396.         CFlowNode_Composite_Input(SActivationInfo* pActInfo) {};
  397.         virtual void GetConfiguration(SFlowNodeConfig& config)
  398.         {
  399.                 static const SOutputPortConfig out_config[] = {
  400.                         OutputPortConfig_AnyType("in"),
  401.                         { 0 }
  402.                 };
  403.                 config.sDescription = _HELP("Input for the composite node");
  404.                 config.pInputPorts = 0;
  405.                 config.pOutputPorts = out_config;
  406.                 config.SetCategory(EFLN_ADVANCED);
  407.         }
  408.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  409.         {
  410.         }
  411. };
  412.  
  413. //////////////////////////////////////////////////////////////////////////
  414. class CFlowNode_Composite_Output : public CFlowBaseNode<eNCT_Singleton>
  415. {
  416. public:
  417.         CFlowNode_Composite_Output(SActivationInfo* pActInfo) {};
  418.         virtual void GetConfiguration(SFlowNodeConfig& config)
  419.         {
  420.                 static const SInputPortConfig in_config[] = {
  421.                         InputPortConfig_AnyType("out"),
  422.                         { 0 }
  423.                 };
  424.                 config.sDescription = _HELP("Output for the composite node");
  425.                 config.pInputPorts = in_config;
  426.                 config.pOutputPorts = 0;
  427.                 config.SetCategory(EFLN_ADVANCED);
  428.         }
  429.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  430.         {
  431.         }
  432. };
  433.  
  434. // REGISTER_FLOW_NODE("Composite:Input", CFlowNode_Composite_Input );
  435. // REGISTER_FLOW_NODE("Composite:Output", CFlowNode_Composite_Output );
  436.  
downloadFlowCompositeNode.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