BVB Source Codes

CRYENGINE Show Module.cpp Source code

Return Download CRYENGINE: download Module.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 "Module.h"
  5.  
  6. #include "FlowSystem/FlowSystem.h"
  7. #include "ModuleManager.h"
  8. #include "FlowModuleNodes.h"
  9. #include "ILevelSystem.h"
  10.  
  11. CFlowGraphModule::CFlowGraphModule(TModuleId moduleId)
  12. {
  13.         m_Id = moduleId;
  14.         m_type = IFlowGraphModule::eT_Global;
  15.         m_pRootGraph = nullptr;
  16.         m_nextInstanceId = 0;
  17.         m_pInstanceBeingCreated = nullptr;
  18.  
  19.         m_startNodeTypeId = InvalidFlowNodeTypeId;
  20.         m_returnNodeTypeId = InvalidFlowNodeTypeId;
  21.         m_callNodeTypeId = InvalidFlowNodeTypeId;
  22. }
  23.  
  24. CFlowGraphModule::~CFlowGraphModule()
  25. {
  26.         Destroy();
  27. }
  28.  
  29. void CFlowGraphModule::Destroy()
  30. {
  31.         ClearCallNodesForInstances();
  32.         ClearGlobalControlNodes();
  33.  
  34.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  35.         {
  36.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  37.                 {
  38.                         instanceIt->second.m_pGraph = nullptr;
  39.                 }
  40.                 entityIt->second.clear();
  41.         }
  42.         m_runningInstances.clear();
  43.  
  44.         m_pRootGraph = nullptr;
  45.  
  46.         UnregisterNodes();
  47. }
  48.  
  49. /* Serialization */
  50.  
  51. bool CFlowGraphModule::PreLoadModule(const char* fileName)
  52. {
  53.         m_fileName = fileName;
  54.  
  55.         XmlNodeRef moduleRef = gEnv->pSystem->LoadXmlFromFile(fileName);
  56.  
  57.         if (!moduleRef)
  58.         {
  59.                 CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Unable to preload Flowgraph Module: %s", PathUtil::GetFileName(fileName).c_str());
  60.                 return false;
  61.         }
  62.  
  63.         assert(!stricmp(moduleRef->getTag(), "Graph"));
  64.  
  65.         bool module = false;
  66.         moduleRef->getAttr("isModule", module);
  67.         assert(module);
  68.  
  69.         XmlString tempName;
  70.         if (moduleRef->getAttr("moduleName", tempName))
  71.                 m_name = tempName;
  72.  
  73.         bool bResult = (m_pRootGraph != NULL);
  74.         assert(m_pRootGraph == NULL);
  75.  
  76.         // first handle module ports
  77.         XmlNodeRef modulePorts = moduleRef->findChild("ModuleInputsOutputs");
  78.         RemoveModulePorts();
  79.         if (modulePorts)
  80.         {
  81.                 int nPorts = modulePorts->getChildCount();
  82.                 for (int i = 0; i < nPorts; ++i)
  83.                 {
  84.                         XmlString portName;
  85.                         int portType;
  86.                         bool isInput;
  87.  
  88.                         XmlNodeRef port = modulePorts->getChild(i);
  89.                         port->getAttr("Name", portName);
  90.                         port->getAttr("Type", portType);
  91.                         port->getAttr("Input", isInput);
  92.  
  93.                         IFlowGraphModule::SModulePortConfig portConfig;
  94.                         portConfig.name = portName.c_str();
  95.                         portConfig.type = (EFlowDataTypes)portType;
  96.                         portConfig.input = isInput;
  97.  
  98.                         AddModulePort(portConfig);
  99.                 }
  100.         }
  101.  
  102.         // and create nodes for this module (needs to be done before actual graph load, so that the
  103.         //      nodes can be created there)
  104.         RegisterNodes();
  105.  
  106.         return bResult;
  107. }
  108.  
  109. bool CFlowGraphModule::LoadModuleGraph(const char* moduleName, const char* fileName)
  110. {
  111.         assert(m_name == moduleName);
  112.         assert(m_fileName == fileName);
  113.  
  114.         XmlNodeRef moduleRef = gEnv->pSystem->LoadXmlFromFile(fileName);
  115.  
  116.         if (!moduleRef)
  117.         {
  118.                 CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Unable to load Flowgraph Module Graph: %s", moduleName);
  119.                 return false;
  120.         }
  121.  
  122.         assert(!stricmp(moduleRef->getTag(), "Graph"));
  123.  
  124.         bool module = false;
  125.         moduleRef->getAttr("isModule", module);
  126.         assert(module);
  127.  
  128.         bool bResult = (m_pRootGraph != NULL);
  129.         assert(m_pRootGraph == NULL);
  130.  
  131.         if (!m_pRootGraph)
  132.         {
  133.                 IFlowSystem* pSystem = gEnv->pFlowSystem;
  134.                 assert(pSystem);
  135.  
  136.                 // Create graph
  137.                 m_pRootGraph = pSystem->CreateFlowGraph();
  138.                 if (m_pRootGraph)
  139.                 {
  140.                         m_pRootGraph->SerializeXML(moduleRef, true);
  141.  
  142.                         // Root graph is for cloning, so not active!
  143.                         m_pRootGraph->UnregisterFromFlowSystem();
  144.                         m_pRootGraph->SetEnabled(false);
  145.                         m_pRootGraph->SetActive(false);
  146.                         bResult = true;
  147.                 }
  148.         }
  149.  
  150.         return bResult;
  151. }
  152.  
  153. bool CFlowGraphModule::SaveModuleXml(XmlNodeRef saveTo)
  154. {
  155.         if (!m_pRootGraph || !saveTo)
  156.                 return false;
  157.  
  158.         saveTo->setAttr("isModule", true);
  159.         saveTo->setAttr("moduleName", m_name);
  160.  
  161.         // NB: don't save our graph here, just the module ports (graph is saved
  162.         //      by the calling code)
  163.  
  164.         if (m_moduleInpPorts.size() > 0 || m_moduleOutPorts.size() > 0)
  165.         {
  166.                 XmlNodeRef inputs = saveTo->newChild("ModuleInputsOutputs");
  167.                 for (size_t i = 0; i < m_moduleInpPorts.size(); ++i)
  168.                 {
  169.                         XmlNodeRef ioChild = inputs->newChild("Port");
  170.                         ioChild->setAttr("Name", m_moduleInpPorts[i].name);
  171.                         ioChild->setAttr("Type", m_moduleInpPorts[i].type);
  172.                         ioChild->setAttr("Input", true);
  173.                 }
  174.                 for (size_t i = 0; i < m_moduleOutPorts.size(); ++i)
  175.                 {
  176.                         XmlNodeRef ioChild = inputs->newChild("Port");
  177.                         ioChild->setAttr("Name", m_moduleOutPorts[i].name);
  178.                         ioChild->setAttr("Type", m_moduleOutPorts[i].type);
  179.                         ioChild->setAttr("Input", false);
  180.                 }
  181.         }
  182.  
  183.         return true;
  184. }
  185.  
  186. /* (Un)Register generated nodes */
  187.  
  188. void CFlowGraphModule::RegisterNodes()
  189. {
  190.         IFlowGraphModuleManager* pMgr = gEnv->pFlowSystem ? gEnv->pFlowSystem->GetIModuleManager() : NULL;
  191.         if (pMgr)
  192.         {
  193.                 m_startNodeTypeId = gEnv->pFlowSystem->RegisterType(pMgr->GetStartNodeName(m_name), new CFlowModuleStartNodeFactory(this));
  194.                 m_returnNodeTypeId = gEnv->pFlowSystem->RegisterType(pMgr->GetReturnNodeName(m_name), new CFlowModuleReturnNodeFactory(this));
  195.                 m_callNodeTypeId = gEnv->pFlowSystem->RegisterType(pMgr->GetCallerNodeName(m_name), new CFlowModuleCallNodeFactory(this));
  196.         }
  197. }
  198.  
  199. void CFlowGraphModule::UnregisterNodes()
  200. {
  201.         IFlowGraphModuleManager* pMgr = gEnv->pFlowSystem ? gEnv->pFlowSystem->GetIModuleManager() : NULL;
  202.         if (pMgr)
  203.         {
  204.                 gEnv->pFlowSystem->UnregisterType(pMgr->GetStartNodeName(m_name));
  205.                 gEnv->pFlowSystem->UnregisterType(pMgr->GetReturnNodeName(m_name));
  206.                 gEnv->pFlowSystem->UnregisterType(pMgr->GetCallerNodeName(m_name));
  207.         }
  208. }
  209.  
  210. /* Module Ports */
  211.  
  212. size_t CFlowGraphModule::GetModuleInputPortCount() const
  213. {
  214.         return m_moduleInpPorts.size();
  215. }
  216.  
  217. size_t CFlowGraphModule::GetModuleOutputPortCount() const
  218. {
  219.         return m_moduleOutPorts.size();
  220. }
  221.  
  222. const IFlowGraphModule::SModulePortConfig* CFlowGraphModule::GetModuleInputPort(size_t index) const
  223. {
  224.         if (index < m_moduleInpPorts.size())
  225.                 return &m_moduleInpPorts[index];
  226.  
  227.         return nullptr;
  228. }
  229.  
  230. const IFlowGraphModule::SModulePortConfig* CFlowGraphModule::GetModuleOutputPort(size_t index) const
  231. {
  232.         if (index < m_moduleOutPorts.size())
  233.                 return &m_moduleOutPorts[index];
  234.  
  235.         return nullptr;
  236. }
  237.  
  238. bool CFlowGraphModule::AddModulePort(const IFlowGraphModule::SModulePortConfig& port)
  239. {
  240.         if (port.input)
  241.         {
  242.                 m_moduleInpPorts.push_back(port);
  243.         }
  244.         else
  245.         {
  246.                 m_moduleOutPorts.push_back(port);
  247.         }
  248.         return true;
  249. }
  250.  
  251. void CFlowGraphModule::RemoveModulePorts()
  252. {
  253.         stl::free_container(m_moduleInpPorts);
  254.         stl::free_container(m_moduleOutPorts);
  255. }
  256.  
  257. /* Instance Handling */
  258.  
  259. inline SModuleInstance* CFlowGraphModule::GetInstance(EntityId entityId, TModuleInstanceId instanceId)
  260. {
  261.         TEntityInstanceMap::iterator entityIte = m_runningInstances.find(entityId);
  262.         if (entityIte != m_runningInstances.end())
  263.         {
  264.                 TInstanceMap::iterator instanceIte = entityIte->second.find(instanceId);
  265.                 if (instanceIte != entityIte->second.end())
  266.                 {
  267.                         return &instanceIte->second;
  268.                 }
  269.         }
  270.  
  271.         return nullptr;
  272. }
  273.  
  274. bool CFlowGraphModule::HasInstanceGraph(IFlowGraphPtr pGraph)
  275. {
  276.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  277.         {
  278.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  279.                 {
  280.                         if (instanceIt->second.m_pGraph == pGraph)
  281.                         {
  282.                                 return true;
  283.                         }
  284.                 }
  285.         }
  286.  
  287.         return false;
  288. }
  289.  
  290. bool CFlowGraphModule::HasRunningInstances() const
  291. {
  292.         for (TEntityInstanceMap::const_iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  293.         {
  294.                 for (TInstanceMap::const_iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  295.                 {
  296.                         if (instanceIt->second.m_bUsed)
  297.                         {
  298.                                 return true;
  299.                         }
  300.                 }
  301.         }
  302.         return false;
  303. }
  304.  
  305. size_t CFlowGraphModule::GetRunningInstancesCount() const
  306. {
  307.         size_t count = 0;
  308.         for (TEntityInstanceMap::const_iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  309.         {
  310.                 for (TInstanceMap::const_iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  311.                 {
  312.                         if (instanceIt->second.m_bUsed)
  313.                         {
  314.                                 count += 1;
  315.                         }
  316.                 }
  317.         }
  318.         return count;
  319. }
  320.  
  321. void CFlowGraphModule::RegisterStartNodeForInstanceBeingCreated(CFlowModuleStartNode* pStartNode)
  322. {
  323.         assert(m_pInstanceBeingCreated);
  324.         if (m_pInstanceBeingCreated)
  325.         {
  326.                 m_pInstanceBeingCreated->SetStartNode(pStartNode);
  327.         }
  328. }
  329.  
  330. void CFlowGraphModule::CreateInstance(EntityId entityId, TModuleInstanceId runningInstanceId)
  331. {
  332.         CRY_PROFILE_REGION_ARG(PROFILE_ACTION, "CFlowGraphModule::CreateInstance", m_name.c_str());
  333.  
  334.         if (m_pRootGraph)
  335.         {
  336.                 // create instance
  337.                 SModuleInstance instance(this, runningInstanceId);
  338.                 instance.m_entityId = entityId;
  339.                 instance.m_bUsed = true;
  340.  
  341.                 // insert in registry
  342.                 TEntityInstanceMap::iterator entityIte = m_runningInstances.find(entityId);
  343.                 if (entityIte == m_runningInstances.end())
  344.                 {
  345.                         entityIte = m_runningInstances.insert(std::make_pair(entityId, TInstanceMap())).first;
  346.                 }
  347.                 TInstanceMap::iterator it = entityIte->second.insert(std::make_pair(runningInstanceId, instance)).first;
  348.  
  349.                 // Clone and instantiate the module's nodes
  350.                 m_pInstanceBeingCreated = &it->second; // expose instance, so start and return nodes grab it when cloned.
  351.                 IFlowGraphPtr pGraphClone = m_pRootGraph->Clone();
  352.                 assert(pGraphClone);
  353.  
  354.                 // Enable the instance's inner nodes
  355.                 pGraphClone->SetType(IFlowGraph::eFGT_Module);
  356.                 pGraphClone->SetEnabled(true);
  357.                 pGraphClone->SetActive(true);
  358.                 pGraphClone->InitializeValues();
  359.                 m_pInstanceBeingCreated->m_pGraph = pGraphClone;
  360.  
  361.                 // Activate 'OnCalled' port for all call nodes
  362.                 const TCallNodesMap* pCallNodes = &m_requestedInstanceIds[entityId][runningInstanceId];
  363.                 for (TCallNodesMap::const_iterator it = pCallNodes->begin(), end = pCallNodes->end(); it != end; ++it)
  364.                 {
  365.                         it->second->OnInstanceStarted(runningInstanceId);
  366.                 }
  367.  
  368.                 // Forward the instance id to the 'OnCalled' port of all global control nodes
  369.                 for (TCallNodesMap::const_iterator it = m_globalControlNodes.begin(), end = m_globalControlNodes.end(); it != end; ++it)
  370.                 {
  371.                         it->second->OnInstanceStarted(runningInstanceId);
  372.                 }
  373.  
  374.                 //notify manager that an instance was created so that the event can be forwarded to listeners
  375.                 CFlowGraphModuleManager* pModuleManager = static_cast<CFlowSystem*>(gEnv->pFlowSystem)->GetModuleManager();
  376.                 pModuleManager->BroadcastModuleInstanceStarted(this, runningInstanceId);
  377.         }
  378. }
  379.  
  380. void CFlowGraphModule::CallDefaultInstanceForEntity(IEntity* pEntity)
  381. {
  382.         if (pEntity)
  383.         {
  384.                 TModuleInstanceId runningInstanceId = MODULEINSTANCE_INVALID;
  385.                 EntityId entityId = pEntity->GetId();
  386.  
  387.                 CreateInstance(entityId, runningInstanceId);
  388.                 m_pInstanceBeingCreated->GetStartNode()->OnUpdateAllInputs(nullptr);
  389.         }
  390. }
  391.  
  392. TModuleInstanceId CFlowGraphModule::CallModuleInstance(EntityId entityId, TModuleInstanceId instanceId, const TModuleParams& params, CFlowModuleCallNode* pCallingNode)
  393. {
  394.         TModuleInstanceId runningInstanceId = instanceId;
  395.         IEntity* pEntity = gEnv->pEntitySystem->GetEntity(entityId);
  396.  
  397.         // is instance already running?
  398.         bool bIsInstanceRunning = false;
  399.  
  400.         TEntityInstanceMap::iterator entityIte = m_runningInstances.find(entityId);
  401.         if (entityIte != m_runningInstances.end())
  402.         {
  403.                 TInstanceMap::iterator instanceIte = entityIte->second.find(instanceId);
  404.                 if (instanceIte != entityIte->second.end())
  405.                 {
  406.                         // yes: update inputs
  407.                         instanceIte->second.GetStartNode()->OnUpdateAllInputs(&params);
  408.                         bIsInstanceRunning = true;
  409.                 }
  410.         }
  411.  
  412.         if (!bIsInstanceRunning)
  413.         {
  414.                 // no: create instance and generate ID if needed
  415.                 if (!pEntity && instanceId == MODULEINSTANCE_INVALID)
  416.                 {
  417.                         runningInstanceId = m_nextInstanceId++;
  418.                         RegisterCallNodeForInstance(entityId, runningInstanceId, pCallingNode->GetId(), pCallingNode);
  419.                 }
  420.  
  421.                 CreateInstance(entityId, runningInstanceId);
  422.  
  423.                 // Send inputs to the instance
  424.                 m_pInstanceBeingCreated->GetStartNode()->OnUpdateAllInputs(&params);
  425.         }
  426.  
  427.         return runningInstanceId;
  428. }
  429.  
  430. void CFlowGraphModule::CallAllModuleInstances(const TModuleParams& params, CFlowModuleCallNode* pCallingNode)
  431. {
  432.         bool bHasRunningInstances = false;
  433.  
  434.         // Send inputs to all running instances
  435.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  436.         {
  437.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  438.                 {
  439.                         if (instanceIt->second.m_bUsed)
  440.                         {
  441.                                 bHasRunningInstances = true;
  442.                                 instanceIt->second.GetStartNode()->OnUpdateAllInputs(&params);
  443.                         }
  444.                 }
  445.         }
  446.  
  447.         // there were no running instances, create one and send inputs
  448.         if (!bHasRunningInstances)
  449.         {
  450.                 CallModuleInstance(INVALID_ENTITYID, MODULEINSTANCE_INVALID, params, pCallingNode);
  451.         }
  452. }
  453.  
  454. void CFlowGraphModule::UpdateInstanceInputPort(EntityId entityId, TModuleInstanceId instanceId, size_t paramIdx, const TFlowInputData& value)
  455. {
  456.         SModuleInstance* pInst = GetInstance(entityId, instanceId);
  457.         if (pInst)
  458.         {
  459.                 pInst->GetStartNode()->OnUpdateSingleInput(paramIdx, value);
  460.         }
  461. }
  462.  
  463. void CFlowGraphModule::UpdateAllInstancesInputPort(size_t paramIdx, const TFlowInputData& value)
  464. {
  465.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  466.         {
  467.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  468.                 {
  469.                         if (instanceIt->second.m_bUsed)
  470.                         {
  471.                                 instanceIt->second.GetStartNode()->OnUpdateSingleInput(paramIdx, value);
  472.                         }
  473.                 }
  474.         }
  475. }
  476.  
  477. void CFlowGraphModule::UpdateInstanceOutputPort(EntityId entityId, TModuleInstanceId instanceId, size_t paramIdx, const TFlowInputData& value)
  478. {
  479.         // pass output to the call node, who will output it if in Continuous Output mode
  480.         const TCallNodesMap* pCallNodes = &m_requestedInstanceIds[entityId][instanceId];
  481.         for (TCallNodesMap::const_iterator it = pCallNodes->begin(), end = pCallNodes->end(); it != end; ++it)
  482.         {
  483.                 it->second->OnInstanceOutput(paramIdx, value);
  484.         }
  485.  
  486.         // pass output to the global control nodes, who will output it if in Continuous Output mode
  487.         for (TCallNodesMap::const_iterator it = m_globalControlNodes.begin(), end = m_globalControlNodes.end(); it != end; ++it)
  488.         {
  489.                 it->second->OnInstanceOutput(paramIdx, value);
  490.         }
  491. }
  492.  
  493. void CFlowGraphModule::OnInstanceFinished(EntityId entityId, TModuleInstanceId instanceId, bool bSuccess, const TModuleParams& params)
  494. {
  495.         DestroyInstance(entityId, instanceId);
  496.  
  497.         // output result for all call nodes of this instance
  498.         const TCallNodesMap* pCallNodes = &m_requestedInstanceIds[entityId][instanceId];
  499.         for (TCallNodesMap::const_iterator it = pCallNodes->begin(), end = pCallNodes->end(); it != end; ++it)
  500.         {
  501.                 it->second->OnInstanceFinished(bSuccess, params);
  502.         }
  503.  
  504.         // output result for all global control nodes
  505.         for (TCallNodesMap::const_iterator it = m_globalControlNodes.begin(), end = m_globalControlNodes.end(); it != end; ++it)
  506.         {
  507.                 it->second->OnInstanceFinished(bSuccess, params);
  508.         }
  509.  
  510.         // notify manager that an instance has finished so that the event can be forwarded to listeners
  511.         CFlowGraphModuleManager* pModuleManager = static_cast<CFlowSystem*>(gEnv->pFlowSystem)->GetModuleManager();
  512.         pModuleManager->BroadcastModuleInstanceFinished(this, instanceId);
  513. }
  514.  
  515. void CFlowGraphModule::CancelInstance(EntityId entityId, TModuleInstanceId instanceId)
  516. {
  517.         SModuleInstance* pInst = GetInstance(entityId, instanceId);
  518.         if (pInst)
  519.         {
  520.                 pInst->GetStartNode()->OnCancel();
  521.         }
  522. }
  523.  
  524. void CFlowGraphModule::CancelAllInstances()
  525. {
  526.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  527.         {
  528.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  529.                 {
  530.                         if (instanceIt->second.m_bUsed)
  531.                         {
  532.                                 instanceIt->second.GetStartNode()->OnCancel();
  533.                         }
  534.                 }
  535.         }
  536. }
  537.  
  538. void CFlowGraphModule::DeactivateInstanceGraph(SModuleInstance* pInstance) const
  539. {
  540.         IFlowGraph* pModuleGraph = pInstance->m_pGraph;
  541.         if (pModuleGraph)
  542.         {
  543.                 pModuleGraph->SetEnabled(false);
  544.                 pModuleGraph->SetActive(false);
  545.  
  546.                 // Deactivate all nodes
  547.                 IFlowNodeIteratorPtr pNodeIter = pModuleGraph->CreateNodeIterator();
  548.                 if (pNodeIter)
  549.                 {
  550.                         TFlowNodeId id = InvalidFlowNodeId;
  551.                         while (pNodeIter->Next(id))
  552.                         {
  553.                                 pModuleGraph->SetRegularlyUpdated(id, false);
  554.                         }
  555.                 }
  556.         }
  557. }
  558.  
  559. bool CFlowGraphModule::DestroyInstance(EntityId entityId, TModuleInstanceId instanceId)
  560. {
  561.         bool bResult = false;
  562.  
  563.         // destroy and remove the instance from the running instances
  564.         SModuleInstance* pInstance = GetInstance(entityId, instanceId);
  565.         if (pInstance)
  566.         {
  567.                 DeactivateInstanceGraph(pInstance);
  568.  
  569.                 // mark as unused. Can't delete the graph at this point as it is still
  570.                 //      in the middle of an update. It will be deleted at end of flow system update.
  571.                 pInstance->m_bUsed = false;
  572.                 bResult = true;
  573.         }
  574.  
  575.         return bResult;
  576. }
  577.  
  578. void CFlowGraphModule::RemoveCompletedInstances()
  579. {
  580.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; )
  581.         {
  582.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; )
  583.                 {
  584.                         if (!instanceIt->second.m_bUsed)
  585.                         {
  586.                                 instanceIt = entityIt->second.erase(instanceIt);
  587.                         }
  588.                         else
  589.                         {
  590.                                 ++instanceIt;
  591.                         }
  592.                 }
  593.                 if (entityIt->second.empty())
  594.                 {
  595.                         entityIt = m_runningInstances.erase(entityIt);
  596.                 }
  597.                 else
  598.                 {
  599.                         ++entityIt;
  600.                 }
  601.         }
  602. }
  603.  
  604. void CFlowGraphModule::RemoveAllInstances()
  605. {
  606.         for (TEntityInstanceMap::iterator entityIt = m_runningInstances.begin(), entityItE = m_runningInstances.end(); entityIt != entityItE; ++entityIt)
  607.         {
  608.                 for (TInstanceMap::iterator instanceIt = entityIt->second.begin(), instanceItE = entityIt->second.end(); instanceIt != instanceItE; ++instanceIt)
  609.                 {
  610.                         if (instanceIt->second.m_bUsed)
  611.                         {
  612.                                 DeactivateInstanceGraph(&instanceIt->second);
  613.                                 instanceIt->second.m_bUsed = false;
  614.                         }
  615.                 }
  616.         }
  617. }
  618.  
  619. /* Keeping track of call nodes for instances */
  620.  
  621. void CFlowGraphModule::RegisterCallNodeForInstance(EntityId entityId, TModuleInstanceId instanceId, uint callNodeId, CFlowModuleCallNode* pCallNode)
  622. {
  623.         // see notes on Instance IDs in Module.h
  624.  
  625.         if (entityId != INVALID_ENTITYID)
  626.         {
  627.                 // valid entity registers any instance ID including -1. there are no generated IDs to keep track of
  628.                 m_requestedInstanceIds[entityId][instanceId][callNodeId] = pCallNode;
  629.         }
  630.         else
  631.         {
  632.                 // no entity. -1 is not a valid instance id to register. keep track of next instance id to be generated
  633.                 if (instanceId != MODULEINSTANCE_INVALID)
  634.                 {
  635.                         m_requestedInstanceIds[entityId][instanceId][callNodeId] = pCallNode;
  636.  
  637.                         if ((instanceId + 1) > m_nextInstanceId)
  638.                         {
  639.                                 m_nextInstanceId = instanceId + 1;
  640.                         }
  641.                 }
  642.         }
  643. }
  644.  
  645. void CFlowGraphModule::UnregisterCallNodeForInstance(EntityId entityId, TModuleInstanceId instanceId, uint callNodeId)
  646. {
  647.         TEntityInstancesToCallNodes::iterator entityIte = m_requestedInstanceIds.find(entityId);
  648.         if (entityIte != m_requestedInstanceIds.end())
  649.         {
  650.                 TInstanceCallNodesMap::iterator instanceIte = entityIte->second.find(instanceId);
  651.                 if (instanceIte != entityIte->second.end())
  652.                 {
  653.                         instanceIte->second.erase(callNodeId);
  654.                 }
  655.         }
  656. }
  657.  
  658. void CFlowGraphModule::ChangeRegisterCallNodeForInstance(
  659.   EntityId oldEntityId, TModuleInstanceId oldInstanceId,
  660.   EntityId newEntityId, TModuleInstanceId newInstanceId,
  661.   uint callNodeId, CFlowModuleCallNode* pCallNode)
  662. {
  663.         if (oldEntityId == newEntityId && oldInstanceId == newInstanceId)
  664.                 return;
  665.  
  666.         UnregisterCallNodeForInstance(oldEntityId, oldInstanceId, callNodeId);
  667.  
  668.         RegisterCallNodeForInstance(newEntityId, newInstanceId, callNodeId, pCallNode);
  669. }
  670.  
  671. void CFlowGraphModule::ClearCallNodesForInstances()
  672. {
  673.         m_requestedInstanceIds.clear();
  674.         m_nextInstanceId = 0;
  675. }
  676.  
  677. /* Keeping track of global control nodes */
  678.  
  679. void CFlowGraphModule::RegisterGlobalControlNode(uint callNodeId, CFlowModuleCallNode* pCallNode)
  680. {
  681.         m_globalControlNodes[callNodeId] = pCallNode;
  682. }
  683.  
  684. void CFlowGraphModule::UnregisterGlobalControlNode(uint callNodeId)
  685. {
  686.         m_globalControlNodes.erase(callNodeId);
  687. }
  688.  
  689. void CFlowGraphModule::ClearGlobalControlNodes()
  690. {
  691.         m_globalControlNodes.clear();
  692. }
  693.  
  694. /* Iterator */
  695.  
  696. IModuleInstanceIteratorPtr CFlowGraphModule::CreateInstanceIterator()
  697. {
  698.         if (m_iteratorPool.empty())
  699.         {
  700.                 return new CInstanceIterator(this);
  701.         }
  702.         else
  703.         {
  704.                 CInstanceIterator* pIter = m_iteratorPool.back();
  705.                 m_iteratorPool.pop_back();
  706.                 new(pIter) CInstanceIterator(this);
  707.                 return pIter;
  708.         }
  709. }
  710.  
downloadModule.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