BVB Source Codes

CRYENGINE Show FlowScriptedNode.cpp Source code

Return Download CRYENGINE: download FlowScriptedNode.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 "FlowScriptedNode.h"
  5. #include <CryScriptSystem/IScriptSystem.h>
  6.  
  7. namespace
  8. {
  9. bool GetCategory(const char* catName, uint32& outCategory)
  10. {
  11.         if (stricmp(catName, "approved") == 0)
  12.                 outCategory = EFLN_APPROVED;
  13.         else if (stricmp(catName, "advanced") == 0)
  14.                 outCategory = EFLN_ADVANCED;
  15.         else if (stricmp(catName, "debug") == 0)
  16.                 outCategory = EFLN_DEBUG;
  17.         else if (stricmp(catName, "legacy") == 0)
  18.                 outCategory = EFLN_OBSOLETE;
  19.         else if (stricmp(catName, "obsolete") == 0)
  20.                 outCategory = EFLN_OBSOLETE;
  21.         else if (stricmp(catName, "wip") == 0)
  22.                 outCategory = EFLN_ADVANCED;
  23.         else
  24.         {
  25.                 //outCategory = EFLN_NOCATEGORY;
  26.                 outCategory = EFLN_DEBUG;
  27.                 return false;
  28.         }
  29.         return true;
  30. }
  31. }
  32.  
  33. class CFlowDataToScriptDataVisitor
  34. {
  35. public:
  36.         CFlowDataToScriptDataVisitor(IScriptTable* pTable, const char* name) : m_pTable(pTable), m_name(name) {}
  37.  
  38.         template<class T>
  39.         void Visit(const T& value)
  40.         {
  41.                 m_pTable->SetValue(m_name, value);
  42.         }
  43.  
  44.         void Visit(const TFlowInputDataVariant& var)
  45.         {
  46.                 VisitVariant(var);
  47.         }
  48.  
  49.         void Visit(EntityId id)
  50.         {
  51.                 ScriptHandle hdl;
  52.                 hdl.n = id;
  53.                 m_pTable->SetValue(m_name, hdl);
  54.         }
  55.  
  56.         void Visit(const string& str)
  57.         {
  58.                 m_pTable->SetValue(m_name, str.c_str());
  59.         }
  60.  
  61.         void Visit(SFlowSystemVoid)
  62.         {
  63.                 m_pTable->SetToNull(m_name);
  64.         }
  65.  
  66.         template<class T>
  67.         void operator()(T& type)
  68.         {
  69.                 Visit(type);
  70.         }
  71.  
  72. private:
  73.         template<size_t I = 0>
  74.         void VisitVariant(const TFlowInputDataVariant& var)
  75.         {
  76.                 if (var.index() == I)
  77.                 {
  78.                         Visit(stl::get<I>(var));
  79.                 }
  80.                 else
  81.                 {
  82.                         VisitVariant<I + 1>(var);
  83.                 }
  84.         }
  85.  
  86.         IScriptTable* m_pTable;
  87.         const char*   m_name;
  88. };
  89. template<>
  90. void CFlowDataToScriptDataVisitor::VisitVariant<stl::variant_size<TFlowInputDataVariant>::value>(const TFlowInputDataVariant& var)
  91. {
  92.         CRY_ASSERT_MESSAGE(false, "Invalid variant index.");
  93. }
  94.  
  95. class CFlowDataToScriptParamVisitor
  96. {
  97. public:
  98.         CFlowDataToScriptParamVisitor(IScriptSystem* pSS) : m_pSS(pSS) {}
  99.  
  100.         template<class T>
  101.         void Visit(const T& value)
  102.         {
  103.                 m_pSS->PushFuncParam(value);
  104.         }
  105.  
  106.         void Visit(const TFlowInputDataVariant& var)
  107.         {
  108.                 VisitVariant(var);
  109.         }
  110.  
  111.         void Visit(EntityId id)
  112.         {
  113.                 ScriptHandle hdl;
  114.                 hdl.n = id;
  115.                 m_pSS->PushFuncParam(hdl);
  116.         }
  117.  
  118.         void Visit(const string& str)
  119.         {
  120.                 m_pSS->PushFuncParam(str.c_str());
  121.         }
  122.  
  123.         void Visit(SFlowSystemVoid)
  124.         {
  125.                 ScriptAnyValue n(svtNull);
  126.                 m_pSS->PushFuncParamAny(n);
  127.         }
  128.  
  129.         template<class T>
  130.         void operator()(T& type)
  131.         {
  132.                 Visit(type);
  133.         }
  134.  
  135. private:
  136.         template<size_t I = 0>
  137.         void VisitVariant(const TFlowInputDataVariant& var)
  138.         {
  139.                 if (var.index() == I)
  140.                 {
  141.                         Visit(stl::get<I>(var));
  142.                 }
  143.                 else
  144.                 {
  145.                         VisitVariant<I + 1>(var);
  146.                 }
  147.         }
  148.  
  149.         IScriptSystem* m_pSS;
  150. };
  151. template<>
  152. void CFlowDataToScriptParamVisitor::VisitVariant<stl::variant_size<TFlowInputDataVariant>::value>(const TFlowInputDataVariant& var)
  153. {
  154.         CRY_ASSERT_MESSAGE(false, "Invalid variant index.");
  155. }
  156.  
  157. /*
  158.  * node
  159.  */
  160.  
  161. CFlowScriptedNode::CFlowScriptedNode(const SActivationInfo* pInfo, CFlowScriptedNodeFactoryPtr pFactory, SmartScriptTable table) :
  162.         m_refs(0), m_info(*pInfo), m_table(table), m_pFactory(pFactory)
  163. {
  164.         ScriptHandle thisHandle;
  165.         thisHandle.ptr = this;
  166.         m_table->SetValue("__this", thisHandle);
  167. }
  168.  
  169. CFlowScriptedNode::~CFlowScriptedNode()
  170. {
  171. }
  172.  
  173. void CFlowScriptedNode::AddRef()
  174. {
  175.         ++m_refs;
  176. }
  177.  
  178. void CFlowScriptedNode::Release()
  179. {
  180.         if (0 == --m_refs)
  181.                 delete this;
  182. }
  183.  
  184. void CFlowScriptedNode::GetMemoryUsage(ICrySizer* s) const
  185. {
  186.         s->Add(*this);
  187. }
  188.  
  189. IFlowNodePtr CFlowScriptedNode::Clone(SActivationInfo* pActInfo)
  190. {
  191.         SmartScriptTable newTable(m_table->GetScriptSystem());
  192.         newTable->Clone(m_table.GetPtr(), true);
  193.         return new CFlowScriptedNode(pActInfo, m_pFactory, newTable);
  194. }
  195.  
  196. void CFlowScriptedNode::GetConfiguration(SFlowNodeConfig& config)
  197. {
  198.         m_pFactory->GetConfiguration(config);
  199. }
  200.  
  201. void CFlowScriptedNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  202. {
  203.         if (event != eFE_Activate)
  204.                 return;
  205.  
  206.         // pass 1: update data
  207.         for (size_t i = 0; i < m_pFactory->NumInputs(); i++)
  208.         {
  209.                 if (pActInfo->pInputPorts[i].IsUserFlagSet())
  210.                 {
  211.                         //TODO
  212.                         //pActInfo->pInputPorts[i].Visit( CFlowDataToScriptDataVisitor(m_table.GetPtr(), m_pFactory->InputName(i)) );
  213.                 }
  214.         }
  215.  
  216.         // pass 2: call OnActivate functions
  217.         for (size_t i = 0; i < m_pFactory->NumInputs(); i++)
  218.         {
  219.                 if (pActInfo->pInputPorts[i].IsUserFlagSet())
  220.                 {
  221.                         static char buffer[256] = "OnActivate_";
  222.                         strcpy(buffer + 11, m_pFactory->InputName(i));
  223.                         Script::CallMethod(m_table.GetPtr(), buffer);
  224.                 }
  225.         }
  226. }
  227.  
  228. void CFlowScriptedNode::Serialize(SActivationInfo* pActInfo, TSerialize ser)
  229. {
  230.         ser.Value("ScriptData", m_table);
  231. }
  232.  
  233. bool CFlowScriptedNode::SerializeXML(SActivationInfo*, const XmlNodeRef& root, bool reading)
  234. {
  235.         // TODO: when we have Lua-XML serialization, add a call here ;)
  236.         return true;
  237. }
  238.  
  239. int CFlowScriptedNode::ActivatePort(IFunctionHandler* pH, size_t nOutput, const TFlowInputData& data)
  240. {
  241.         m_info.pGraph->ActivatePort(SFlowAddress(m_info.myID, static_cast<TFlowPortId>(nOutput), true), data);
  242.         return pH->EndFunction();
  243. }
  244.  
  245. /*
  246.  * factory
  247.  */
  248.  
  249. CFlowScriptedNodeFactory::CFlowScriptedNodeFactory()
  250. {
  251.         m_refs = 0;
  252. }
  253.  
  254. CFlowScriptedNodeFactory::~CFlowScriptedNodeFactory()
  255. {
  256. }
  257.  
  258. bool CFlowScriptedNodeFactory::Init(const char* path, const char* nodeName)
  259. {
  260.         static SInputPortConfig termInput = { 0 };
  261.         static SOutputPortConfig termOutput = { 0 };
  262.  
  263.         IScriptSystem* pSS = gEnv->pScriptSystem;
  264.         if (!pSS->ExecuteFile(path))
  265.                 return false;
  266.         if (!pSS->GetGlobalValue(nodeName, m_table))
  267.                 return false;
  268.  
  269.         SmartScriptTable inputs;
  270.         if (m_table->GetValue("Inputs", inputs))
  271.         {
  272.                 int n = inputs->Count();
  273.                 for (int i = 1; i <= n; i++)
  274.                 {
  275.                         const char* cname;
  276.                         if (inputs->GetAt(i, cname))
  277.                         {
  278.                                 const string& name = AddString(cname);
  279.                                 m_inputs.push_back(InputPortConfig_AnyType(name.c_str()));
  280.                         }
  281.                 }
  282.         }
  283.         m_inputs.push_back(termInput);
  284.         SmartScriptTable outputs;
  285.         if (m_table->GetValue("Outputs", outputs))
  286.         {
  287.                 int n = outputs->Count();
  288.                 for (int i = 1; i <= n; i++)
  289.                 {
  290.                         const char* cname;
  291.                         if (outputs->GetAt(i, cname))
  292.                         {
  293.                                 const string& name = AddString(cname);
  294.                                 size_t idx = m_outputs.size();
  295.                                 m_outputs.push_back(OutputPortConfig_AnyType(name.c_str()));
  296.  
  297.                                 string activateName = "Activate_" + name;
  298.  
  299.                                 IScriptTable::SUserFunctionDesc fd;
  300.                                 fd.pUserDataFunc = ActivateFunction;
  301.                                 fd.sFunctionName = activateName.c_str();
  302.                                 fd.nDataSize = sizeof(size_t);
  303.                                 fd.pDataBuffer = &idx;
  304.                                 fd.sGlobalName = name.c_str();
  305.                                 fd.sFunctionParams = "value";
  306.  
  307.                                 m_table->AddFunction(fd);
  308.                         }
  309.                 }
  310.         }
  311.         m_outputs.push_back(termOutput);
  312.  
  313.         char* categoryString = 0;
  314.         m_table->GetValue("Category", categoryString);
  315.         if (categoryString)
  316.         {
  317.                 if (GetCategory(categoryString, m_category) == false)
  318.                 {
  319.                         GameWarning("[flow] Unrecognized Category '%s' in ScriptedFlowNode '%s'", categoryString, nodeName);
  320.                 }
  321.         }
  322.         else
  323.                 m_category = EFLN_DEBUG;
  324.         //m_category = EFLN_NOCATEGORY;
  325.  
  326.         return true;
  327. }
  328.  
  329. void CFlowScriptedNodeFactory::AddRef()
  330. {
  331.         ++m_refs;
  332. }
  333.  
  334. void CFlowScriptedNodeFactory::Release()
  335. {
  336.         if (0 == --m_refs)
  337.                 delete this;
  338. }
  339.  
  340. IFlowNodePtr CFlowScriptedNodeFactory::Create(IFlowNode::SActivationInfo* pInfo)
  341. {
  342.         SmartScriptTable newTable(m_table->GetScriptSystem());
  343.         newTable->Clone(m_table.GetPtr(), true);
  344.         return new CFlowScriptedNode(pInfo, this, newTable);
  345. }
  346.  
  347. void CFlowScriptedNodeFactory::GetConfiguration(SFlowNodeConfig& config)
  348. {
  349.         config.pInputPorts = &m_inputs[0];
  350.         config.pOutputPorts = &m_outputs[0];
  351.         config.SetCategory(m_category);
  352. }
  353.  
  354. const string& CFlowScriptedNodeFactory::AddString(const char* c_str)
  355. {
  356.         string str = c_str;
  357.         return *m_stringTable.insert(str).first;
  358. }
  359.  
  360. int CFlowScriptedNodeFactory::ActivateFunction(IFunctionHandler* pH, void* pBuffer, int nSize)
  361. {
  362.         // TODO: log errors
  363.         IScriptSystem* pSS = pH->GetIScriptSystem();
  364.  
  365.         CRY_ASSERT(nSize == sizeof(size_t));
  366.         size_t nOutput = *(size_t*)pBuffer;
  367.  
  368.         ScriptHandle hdl;
  369.         SmartScriptTable tblNode;
  370.  
  371.         SmartScriptTable pTable = NULL;
  372.         ScriptHandle pVoidNode;
  373.         if (!pH->GetParam(1, pTable) || !pTable)
  374.                 return pH->EndFunction();
  375.         if (!pTable->GetValue("__this", pVoidNode) || !pVoidNode.ptr)
  376.                 return pH->EndFunction();
  377.         CFlowScriptedNode* pNode = (CFlowScriptedNode*) pVoidNode.ptr;
  378.  
  379.         static const int IDX = 2;
  380.         switch (pH->GetParamType(IDX))
  381.         {
  382.         case svtNull:
  383.                 return pNode->ActivatePort(pH, nOutput, TFlowInputData());
  384.         case svtString:
  385.                 {
  386.                         const char* temp;
  387.                         pH->GetParam(IDX, temp);
  388.                         return pNode->ActivatePort(pH, nOutput, TFlowInputData(string(temp)));
  389.                 }
  390.         case svtNumber:
  391.                 {
  392.                         float temp;
  393.                         pH->GetParam(IDX, temp);
  394.                         return pNode->ActivatePort(pH, nOutput, TFlowInputData(temp));
  395.                 }
  396.         case svtBool:
  397.                 {
  398.                         bool temp;
  399.                         pH->GetParam(IDX, temp);
  400.                         return pNode->ActivatePort(pH, nOutput, TFlowInputData(temp));
  401.                 }
  402.         default:
  403.                 pSS->RaiseError("Unknown or unsupported ScriptVarType %d", pH->GetParamType(IDX));
  404.         }
  405.  
  406.         return pH->EndFunction();
  407. }
  408.  
  409. void CFlowScriptedNodeFactory::GetMemoryUsage(ICrySizer* s) const
  410. {
  411.         SIZER_SUBCOMPONENT_NAME(s, "CFlowScriptedNodeFactory");
  412.         s->Add(*this);
  413.         s->AddObject(m_stringTable);
  414.         s->AddObject(m_inputs);
  415.         s->AddObject(m_outputs);
  416.         for (std::set<string>::const_iterator iter = m_stringTable.begin(); iter != m_stringTable.end(); ++iter)
  417.                 s->Add(*iter);
  418.         for (size_t i = 0; i < m_inputs.size(); i++)
  419.                 m_inputs[i].defaultData.GetMemoryStatistics(s);
  420. }
  421.  
  422. /*
  423.  * CFlowSimpleScriptedNode
  424.  */
  425.  
  426. CFlowSimpleScriptedNode::CFlowSimpleScriptedNode(const SActivationInfo* pInfo, CFlowSimpleScriptedNodeFactoryPtr pFactory) :
  427.         m_refs(0), m_pFactory(pFactory)
  428. {
  429. }
  430.  
  431. CFlowSimpleScriptedNode::~CFlowSimpleScriptedNode()
  432. {
  433. }
  434.  
  435. void CFlowSimpleScriptedNode::AddRef()
  436. {
  437.         ++m_refs;
  438. }
  439.  
  440. void CFlowSimpleScriptedNode::Release()
  441. {
  442.         if (0 >= --m_refs)
  443.                 delete this;
  444. }
  445.  
  446. IFlowNodePtr CFlowSimpleScriptedNode::Clone(SActivationInfo* pActInfo)
  447. {
  448.         return new CFlowSimpleScriptedNode(pActInfo, m_pFactory);
  449. }
  450.  
  451. void CFlowSimpleScriptedNode::GetConfiguration(SFlowNodeConfig& config)
  452. {
  453.         m_pFactory->GetConfiguration(config);
  454. }
  455.  
  456. void CFlowSimpleScriptedNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  457. {
  458.         IScriptSystem* pSS = gEnv->pScriptSystem;
  459.         switch (event)
  460.         {
  461.         case eFE_Activate:
  462.  
  463.                 for (size_t i = 0; i < m_pFactory->NumInputs(); i++)
  464.                 {
  465.                         if (pActInfo->pInputPorts[i].IsUserFlagSet() && (m_pFactory->GetActivateFlags() & (1 << i)))
  466.                         {
  467.                                 pActInfo->pGraph->RequestFinalActivation(pActInfo->myID);
  468.                                 break;
  469.                         }
  470.                 }
  471.                 break;
  472.         case eFE_Initialize:
  473.                 break;
  474.         case eFE_FinalActivate:
  475.                 m_pFactory->CallFunction(pActInfo);
  476.                 break;
  477.         }
  478. }
  479.  
  480. void CFlowSimpleScriptedNode::Serialize(SActivationInfo* pActInfo, TSerialize ser)
  481. {
  482. }
  483.  
  484. bool CFlowSimpleScriptedNode::SerializeXML(SActivationInfo*, const XmlNodeRef& root, bool reading)
  485. {
  486.         return true;
  487. }
  488.  
  489. /*
  490.  * CFlowSimpleScriptedNodeFactory
  491.  */
  492.  
  493. CFlowSimpleScriptedNodeFactory::CFlowSimpleScriptedNodeFactory() : m_refs(0), m_func(0), activateFlags(0)
  494. {
  495. }
  496.  
  497. CFlowSimpleScriptedNodeFactory::~CFlowSimpleScriptedNodeFactory()
  498. {
  499.         if (m_func)
  500.                 gEnv->pScriptSystem->ReleaseFunc(m_func);
  501. }
  502.  
  503. bool CFlowSimpleScriptedNodeFactory::Init(const char* path, const char* nodeName)
  504. {
  505.         static SInputPortConfig termInput = { 0 };
  506.         static SOutputPortConfig termOutput = { 0 };
  507.         activateFlags = 0;
  508.  
  509.         if (const char* p = strchr(nodeName, ':'))
  510.                 nodeName = p + 1;
  511.  
  512.         IScriptSystem* pSS = gEnv->pScriptSystem;
  513.         if (!pSS->ExecuteFile(path))
  514.                 return false;
  515.         SmartScriptTable pTable;
  516.         if (!pSS->GetGlobalValue(nodeName, pTable))
  517.                 return false;
  518.  
  519.         SmartScriptTable inputs;
  520.         if (pTable->GetValue("Inputs", inputs))
  521.         {
  522.                 int nItems = inputs->Count();
  523.                 for (int i = 1; i <= nItems; i++)
  524.                 {
  525.                         SmartScriptTable tbl;
  526.                         if (inputs->GetAt(i, tbl))
  527.                         {
  528.                                 const char* cname;
  529.                                 const char* dname;
  530.                                 const char* enumStr;
  531.                                 const char* type;
  532.                                 if (!tbl->GetAt(1, cname) || !tbl->GetAt(2, type))
  533.                                 {
  534.                                         GameWarning("Element %d is incorrect - should be {name,type} or {name,type,help}", i);
  535.                                         return false;
  536.                                 }
  537.                                 const string& name = AddString(cname);
  538.  
  539.                                 // find which ports will trigger an activation
  540.                                 // their names start by 't_'
  541.                                 activateFlags |= ((name[0] == 't') && (name[1] == '_')) ? (1 << (i - 1)) : 0;
  542.  
  543.                                 if (tbl->GetAt(3, dname)) // Get description if supplied
  544.                                         dname = AddString(dname).c_str();
  545.                                 else
  546.                                         dname = 0;
  547.  
  548.                                 if (tbl->GetAt(4, enumStr)) // Get enumeration string if supplied
  549.                                         enumStr = AddString(enumStr).c_str();
  550.                                 else
  551.                                         enumStr = 0;
  552.  
  553.                                 if (0 == strcmp("string", type))
  554.                                         m_inputs.push_back(InputPortConfig<string>(name.c_str(), dname, NULL, enumStr));
  555.                                 else if (0 == strcmp("bool", type))
  556.                                         m_inputs.push_back(InputPortConfig<bool>(name.c_str(), dname, NULL, enumStr));
  557.                                 else if (0 == strcmp("entityid", type))
  558.                                         m_inputs.push_back(InputPortConfig<EntityId>(name.c_str(), dname, NULL, enumStr));
  559.                                 else if (0 == strcmp("int", type))
  560.                                         m_inputs.push_back(InputPortConfig<int>(name.c_str(), dname, NULL, enumStr));
  561.                                 else if (0 == strcmp("float", type))
  562.                                         m_inputs.push_back(InputPortConfig<float>(name.c_str(), dname, NULL, enumStr));
  563.                                 else if (0 == strcmp("vec3", type))
  564.                                         m_inputs.push_back(InputPortConfig<Vec3>(name.c_str(), dname, NULL, enumStr));
  565.                                 else
  566.                                 {
  567.                                         GameWarning("Unknown type %s", type);
  568.                                         return false;
  569.                                 }
  570.                         }
  571.                         else
  572.                         {
  573.                                 GameWarning("Table is of incorrect format");
  574.                                 return false;
  575.                         }
  576.                 }
  577.         }
  578.         m_inputs.push_back(termInput);
  579.         SmartScriptTable outputs;
  580.         if (pTable->GetValue("Outputs", outputs))
  581.         {
  582.                 int nItems = outputs->Count();
  583.                 for (int i = 1; i <= nItems; i++)
  584.                 {
  585.                         SmartScriptTable tbl;
  586.                         if (outputs->GetAt(i, tbl))
  587.                         {
  588.                                 const char* cname;
  589.                                 const char* dname;
  590.                                 const char* type;
  591.                                 if (!tbl->GetAt(1, cname) || !tbl->GetAt(2, type))
  592.                                 {
  593.                                         GameWarning("Element %d is incorrect - should be {name,type} or {name,type,help}", i);
  594.                                         return false;
  595.                                 }
  596.                                 const string& name = AddString(cname);
  597.  
  598.                                 if (tbl->GetAt(3, dname)) // Get description if supplied
  599.                                         dname = AddString(dname).c_str();
  600.                                 else
  601.                                         dname = 0;
  602.  
  603.                                 if (0 == strcmp("string", type))
  604.                                         m_outputs.push_back(OutputPortConfig<string>(name.c_str(), dname));
  605.                                 else if (0 == strcmp("bool", type))
  606.                                         m_outputs.push_back(OutputPortConfig<bool>(name.c_str(), dname));
  607.                                 else if (0 == strcmp("entityid", type))
  608.                                         m_outputs.push_back(OutputPortConfig<EntityId>(name.c_str(), dname));
  609.                                 else if (0 == strcmp("int", type))
  610.                                         m_outputs.push_back(OutputPortConfig<int>(name.c_str(), dname));
  611.                                 else if (0 == strcmp("float", type))
  612.                                         m_outputs.push_back(OutputPortConfig<float>(name.c_str(), dname));
  613.                                 else if (0 == strcmp("vec3", type))
  614.                                         m_outputs.push_back(OutputPortConfig<Vec3>(name.c_str(), dname));
  615.                                 else
  616.                                 {
  617.                                         GameWarning("Unknown type %s", type);
  618.                                         return false;
  619.                                 }
  620.                         }
  621.                         else
  622.                         {
  623.                                 GameWarning("Table is of incorrect format");
  624.                                 return false;
  625.                         }
  626.                 }
  627.                 m_outputValues.resize(m_outputs.size());
  628.         }
  629.         m_outputs.push_back(termOutput);
  630.  
  631.         if (!pTable->GetValue("Implementation", m_func))
  632.         {
  633.                 return false;
  634.         }
  635.  
  636.         char* categoryString = 0;
  637.         pTable->GetValue("Category", categoryString);
  638.         if (categoryString)
  639.         {
  640.                 if (GetCategory(categoryString, m_category) == false)
  641.                 {
  642.                         GameWarning("[flow] Unrecognized Category '%s' in ScriptedFlowNode '%s'", categoryString, nodeName);
  643.                 }
  644.         }
  645.         else
  646.                 m_category = EFLN_DEBUG;
  647.         //m_category = EFLN_NOCATEGORY;
  648.  
  649.         return true;
  650. }
  651.  
  652. bool CFlowSimpleScriptedNodeFactory::CallFunction(IFlowNode::SActivationInfo* pActInfo)
  653. {
  654.         if (!m_func)
  655.                 return false;
  656.  
  657.         IScriptSystem* pSS = gEnv->pScriptSystem;
  658.  
  659.         pSS->BeginCall(m_func);
  660.         for (size_t i = 0; i < m_inputs.size() - 1; i++)
  661.         {
  662.                 CFlowDataToScriptParamVisitor visitor(pSS);
  663.                 pActInfo->pInputPorts[i].Visit(visitor);
  664.         }
  665.  
  666.         if (pSS->EndCallAnyN(m_outputValues.size(), &m_outputValues[0]))
  667.         {
  668.                 for (size_t i = 0; i < m_outputs.size() - 1; i++)
  669.                 {
  670.                         SFlowAddress port(pActInfo->myID, static_cast<TFlowPortId>(i), true);
  671.  
  672.                         switch (m_outputValues[i].type)
  673.                         {
  674.                         case ANY_TNIL:
  675.                                 pActInfo->pGraph->ActivatePort(port, SFlowSystemVoid());
  676.                                 break;
  677.                         case ANY_TBOOLEAN:
  678.                                 pActInfo->pGraph->ActivatePort(port, m_outputValues[i].b);
  679.                                 break;
  680.                         case ANY_THANDLE:
  681.                                 pActInfo->pGraph->ActivatePort(port, EntityId(m_outputValues[i].ud.nRef));
  682.                                 break;
  683.                         case ANY_TNUMBER:
  684.                                 pActInfo->pGraph->ActivatePort(port, m_outputValues[i].number);
  685.                                 break;
  686.                         case ANY_TSTRING:
  687.                                 pActInfo->pGraph->ActivatePort(port, string(m_outputValues[i].str));
  688.                                 break;
  689.                         case ANY_TTABLE:
  690.                                 {
  691.                                         float x, y, z;
  692.                                         IScriptTable* pTable = m_outputValues[i].table;
  693.                                         if (pTable->GetValue("x", x))
  694.                                                 if (pTable->GetValue("y", y))
  695.                                                         if (pTable->GetValue("z", z))
  696.                                                                 pActInfo->pGraph->ActivatePort(port, Vec3(x, y, z));
  697.                                 }
  698.                                 break;
  699.                         case ANY_TVECTOR:
  700.                                 {
  701.                                         Vec3 v;
  702.                                         v.x = m_outputValues[i].vec3.x;
  703.                                         v.y = m_outputValues[i].vec3.y;
  704.                                         v.z = m_outputValues[i].vec3.z;
  705.                                         pActInfo->pGraph->ActivatePort(port, v);
  706.                                 }
  707.                                 break;
  708.                         }
  709.                 }
  710.         }
  711.         return true;
  712. }
  713.  
  714. void CFlowSimpleScriptedNodeFactory::AddRef()
  715. {
  716.         ++m_refs;
  717. }
  718.  
  719. void CFlowSimpleScriptedNodeFactory::Release()
  720. {
  721.         if (0 == --m_refs)
  722.                 delete this;
  723. }
  724.  
  725. IFlowNodePtr CFlowSimpleScriptedNodeFactory::Create(IFlowNode::SActivationInfo* pInfo)
  726. {
  727.         return new CFlowSimpleScriptedNode(pInfo, this);
  728. }
  729.  
  730. void CFlowSimpleScriptedNodeFactory::GetConfiguration(SFlowNodeConfig& config)
  731. {
  732.         config.pInputPorts = &m_inputs[0];
  733.         config.pOutputPorts = &m_outputs[0];
  734.         config.SetCategory(m_category);
  735. }
  736.  
  737. const string& CFlowSimpleScriptedNodeFactory::AddString(const char* c_str)
  738. {
  739.         string str = c_str;
  740.         return *m_stringTable.insert(str).first;
  741. }
  742.  
  743. void CFlowSimpleScriptedNodeFactory::GetMemoryUsage(ICrySizer* s) const
  744. {
  745.         SIZER_SUBCOMPONENT_NAME(s, "CFlowSimpleScriptedNodeFactory");
  746.         s->Add(*this);
  747.         s->AddObject(m_stringTable);
  748.         s->AddObject(m_inputs);
  749.         s->AddObject(m_outputs);
  750.         s->AddObject(m_outputValues);
  751. }
  752.  
downloadFlowScriptedNode.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