BVB Source Codes

CRYENGINE Show ModuleManager.cpp Source code

Return Download CRYENGINE: download ModuleManager.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 "ModuleManager.h"
  5.  
  6. #include "Module.h"
  7. #include "FlowModuleNodes.h"
  8. #include "ILevelSystem.h"
  9. #include <CryFlowGraph/IFlowBaseNode.h>
  10.  
  11. #define MODULE_FOLDER_NAME ("\\FlowgraphModules\\")
  12.  
  13. #if !defined (_RELEASE)
  14. void RenderModuleDebugInfo();
  15. #endif
  16.  
  17. AllocateConstIntCVar(CFlowGraphModuleManager, CV_fg_debugmodules);
  18.  
  19. IFlowGraphModule* CFlowGraphModuleManager::CModuleIterator::Next()
  20. {
  21.         if (m_cur == m_pModuleManager->m_Modules.end())
  22.                 return NULL;
  23.         IFlowGraphModule* pCur = m_cur->second;
  24.         ++m_cur;
  25.         return pCur;
  26. }
  27.  
  28. //////////////////////////////////////////////////////////////////////////
  29.  
  30. CFlowGraphModuleManager::CFlowGraphModuleManager()
  31.         : m_listeners(1)
  32. {
  33.         m_nextModuleId = 0;
  34.         gEnv->pSystem->GetISystemEventDispatcher()->RegisterListener(this);
  35.  
  36.         DefineConstIntCVarName("fg_debugmodules", CV_fg_debugmodules, 0, VF_NULL, "Display Flowgraph Modules debug information.\n" \
  37.           "0=Disabled"                                                                                           \
  38.           "1=Modules only"                                                                                       \
  39.           "2=Modules + Module Instances");
  40.         fg_debugmodules_filter = REGISTER_STRING("fg_debugmodules_filter", "", VF_NULL,
  41.                                                  "List of module names to display with the CVar 'fg_debugmodules'. Partial names can be supplied, but not regular expressions.");
  42.  
  43. #if !defined (_RELEASE)
  44.         CRY_ASSERT_MESSAGE(gEnv->pGameFramework, "Unable to register as Framework listener!");
  45.         if (gEnv->pGameFramework)
  46.         {
  47.                 gEnv->pGameFramework->RegisterListener(this, "FlowGraphModuleManager", FRAMEWORKLISTENERPRIORITY_GAME);
  48.         }
  49. #endif
  50. }
  51.  
  52. CFlowGraphModuleManager::~CFlowGraphModuleManager()
  53. {
  54.         Shutdown();
  55.         gEnv->pSystem->GetISystemEventDispatcher()->RemoveListener(this);
  56.  
  57.         gEnv->pConsole->UnregisterVariable("fg_debugmodules_filter", true);
  58.  
  59. #if !defined (_RELEASE)
  60.         if (gEnv->pGameFramework)
  61.         {
  62.                 gEnv->pGameFramework->UnregisterListener(this);
  63.         }
  64. #endif
  65. }
  66.  
  67. void CFlowGraphModuleManager::Shutdown()
  68. {
  69.         ClearModules();
  70.         m_listeners.Clear();
  71. }
  72.  
  73. void CFlowGraphModuleManager::ClearModules()
  74. {
  75.         TModuleMap::iterator i = m_Modules.begin();
  76.         TModuleMap::iterator end = m_Modules.end();
  77.         for (; i != end; ++i)
  78.         {
  79.                 if (i->second)
  80.                 {
  81.                         for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  82.                         {
  83.                                 notifier->OnModuleDestroyed(i->second);
  84.                         }
  85.  
  86.                         i->second->Destroy();
  87.                         SAFE_DELETE(i->second);
  88.  
  89.                         for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  90.                         {
  91.                                 notifier->OnPostModuleDestroyed();
  92.                         }
  93.                 }
  94.         }
  95.         m_Modules.clear();
  96.         m_ModuleIds.clear();
  97.         m_ModulesPathInfo.clear();
  98.         m_nextModuleId = 0;
  99. }
  100.  
  101. /* Serialization */
  102.  
  103. CFlowGraphModule* CFlowGraphModuleManager::PreLoadModuleFile(const char* moduleName, const char* fileName, bool bGlobal)
  104. {
  105.         // NB: the module name passed in might be a best guess based on the filename. The actual name
  106.         // comes from within the module xml.
  107.  
  108.         // first check for existing module
  109.         CFlowGraphModule* pModule = static_cast<CFlowGraphModule*>(GetModule(moduleName));
  110.         if (pModule)
  111.         {
  112.                 for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  113.                 {
  114.                         notifier->OnModuleDestroyed(pModule);
  115.                 }
  116.                 // exists, reload
  117.                 pModule->Destroy();
  118.                 pModule->PreLoadModule(fileName);
  119.  
  120.                 for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  121.                 {
  122.                         notifier->OnPostModuleDestroyed();
  123.                 }
  124.         }
  125.         else
  126.         {
  127.                 // not found, create
  128.                 pModule = new CFlowGraphModule(m_nextModuleId++);
  129.                 pModule->SetType(bGlobal ? IFlowGraphModule::eT_Global : IFlowGraphModule::eT_Level);
  130.  
  131.                 TModuleId id = pModule->GetId();
  132.                 m_Modules[id] = pModule;
  133.  
  134.                 pModule->PreLoadModule(fileName);
  135.                 AddModulePathInfo(pModule->GetName(), fileName);
  136.  
  137.                 m_ModuleIds[pModule->GetName()] = id;
  138.         }
  139.  
  140.         return pModule;
  141. }
  142.  
  143. void CFlowGraphModuleManager::LoadModuleGraph(const char* moduleName, const char* fileName, IFlowGraphModuleListener::ERootGraphChangeReason rootGraphChangeReason)
  144. {
  145.         LOADING_TIME_PROFILE_SECTION_ARGS(fileName);
  146.         // first check for existing module - must exist by this point
  147.         CFlowGraphModule* pModule = static_cast<CFlowGraphModule*>(GetModule(moduleName));
  148.         assert(pModule);
  149.  
  150.         if (pModule)
  151.         {
  152.                 if (pModule->LoadModuleGraph(moduleName, fileName))
  153.                 {
  154.                         for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  155.                         {
  156.                                 notifier->OnRootGraphChanged(pModule, rootGraphChangeReason);
  157.                         }
  158.                 }
  159.         }
  160. }
  161.  
  162. IFlowGraphModule* CFlowGraphModuleManager::LoadModuleFile(const char* moduleName, const char* fileName, bool bGlobal)
  163. {
  164.         // first check for existing module
  165.         CFlowGraphModule* pModule = static_cast<CFlowGraphModule*>(GetModule(moduleName));
  166.         if (pModule)
  167.         {
  168.                 for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  169.                 {
  170.                         notifier->OnModuleDestroyed(pModule);
  171.                 }
  172.  
  173.                 pModule->Destroy();
  174.  
  175.                 for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  176.                 {
  177.                         notifier->OnPostModuleDestroyed();
  178.                 }
  179.         }
  180.  
  181.         pModule = PreLoadModuleFile(moduleName, fileName, bGlobal);
  182.         LoadModuleGraph(moduleName, fileName, IFlowGraphModuleListener::ERootGraphChangeReason::LoadModuleFile);
  183.  
  184.         return pModule;
  185. }
  186.  
  187. bool CFlowGraphModuleManager::DeleteModuleXML(const char* moduleName)
  188. {
  189.         if (m_ModulesPathInfo.empty())
  190.                 return false;
  191.  
  192.         TModulesPathInfo::iterator modulePathEntry = m_ModulesPathInfo.find(moduleName);
  193.         if (m_ModulesPathInfo.end() != modulePathEntry)
  194.         {
  195.                 if (remove(modulePathEntry->second) == 0)
  196.                 {
  197.                         m_ModulesPathInfo.erase(moduleName);
  198.  
  199.                         // also remove module itself
  200.                         TModuleIdMap::iterator idIt = m_ModuleIds.find(moduleName);
  201.                         assert(idIt != m_ModuleIds.end());
  202.                         TModuleId id = idIt->second;
  203.                         TModuleMap::iterator modIt = m_Modules.find(id);
  204.                         assert(modIt != m_Modules.end());
  205.  
  206.                         if (modIt != m_Modules.end() && idIt != m_ModuleIds.end())
  207.                         {
  208.                                 for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  209.                                 {
  210.                                         notifier->OnModuleDestroyed(GetModule(id));
  211.                                 }
  212.  
  213.                                 m_Modules[id]->Destroy();
  214.                                 delete m_Modules[id];
  215.                                 m_Modules[id] = NULL;
  216.  
  217.                                 m_ModuleIds.erase(idIt);
  218.                                 m_Modules.erase(modIt);
  219.  
  220.                                 if (m_Modules.empty())
  221.                                         m_nextModuleId = 0;
  222.  
  223.                                 for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  224.                                 {
  225.                                         notifier->OnPostModuleDestroyed();
  226.                                 }
  227.                         }
  228.  
  229.                         return true;
  230.                 }
  231.         }
  232.  
  233.         return false;
  234. }
  235.  
  236. bool CFlowGraphModuleManager::RenameModuleXML(const char* moduleName, const char* newName)
  237. {
  238.         if (m_ModulesPathInfo.empty())
  239.                 return false;
  240.  
  241.         TModulesPathInfo::iterator modulePathEntry = m_ModulesPathInfo.find(moduleName);
  242.         if (m_ModulesPathInfo.end() != modulePathEntry)
  243.         {
  244.                 string newNameWithPath = PathUtil::GetPathWithoutFilename(modulePathEntry->second);
  245.                 newNameWithPath += newName;
  246.                 newNameWithPath += ".xml";
  247.  
  248.                 if (rename(modulePathEntry->second, newNameWithPath.c_str()) == 0)
  249.                 {
  250.                         m_ModulesPathInfo.insert(TModulesPathInfo::value_type(PathUtil::GetFileName(newNameWithPath), newNameWithPath));
  251.                         m_ModulesPathInfo.erase(moduleName);
  252.                         return true;
  253.                 }
  254.         }
  255.  
  256.         return false;
  257. }
  258.  
  259. void CFlowGraphModuleManager::ScanFolder(const string& folderName, bool bGlobal)
  260. {
  261.         _finddata_t fd;
  262.         intptr_t handle = 0;
  263.         ICryPak* pPak = gEnv->pCryPak;
  264.  
  265.         CryFixedStringT<512> searchString = folderName.c_str();
  266.         searchString.append("*.*");
  267.  
  268.         handle = pPak->FindFirst(searchString.c_str(), &fd);
  269.  
  270.         CryFixedStringT<512> moduleName("");
  271.         string newFolder("");
  272.  
  273.         if (handle > -1)
  274.         {
  275.                 do
  276.                 {
  277.                         if (!strcmp(fd.name, ".") || !strcmp(fd.name, "..") || (fd.attrib & _A_HIDDEN))
  278.                                 continue;
  279.  
  280.                         if (fd.attrib & _A_SUBDIR)
  281.                         {
  282.                                 newFolder = folderName;
  283.                                 newFolder = newFolder + fd.name;
  284.                                 newFolder = newFolder + "\\";
  285.                                 ScanFolder(newFolder, bGlobal);
  286.                         }
  287.                         else
  288.                         {
  289.                                 moduleName = fd.name;
  290.                                 if (!strcmpi(PathUtil::GetExt(moduleName.c_str()), "xml"))
  291.                                 {
  292.                                         PathUtil::RemoveExtension(moduleName);
  293.                                         PathUtil::MakeGamePath(folderName);
  294.  
  295.                                         // initial load: creates module, registers nodes
  296.                                         CFlowGraphModule* pModule = PreLoadModuleFile(moduleName.c_str(), PathUtil::GetPathWithoutFilename(folderName) + fd.name, bGlobal);
  297.                                         // important: the module should be added using its internal name rather than the filename
  298.                                         m_ModulesPathInfo.insert(TModulesPathInfo::value_type(pModule->GetName(), PathUtil::GetPathWithoutFilename(folderName) + fd.name));
  299.                                 }
  300.                         }
  301.  
  302.                 }
  303.                 while (pPak->FindNext(handle, &fd) >= 0);
  304.  
  305.                 pPak->FindClose(handle);
  306.         }
  307. }
  308.  
  309. void CFlowGraphModuleManager::RescanModuleNames(bool bGlobal)
  310. {
  311.         LOADING_TIME_PROFILE_SECTION;
  312.         CryFixedStringT<512> path = "";
  313.  
  314.         if (bGlobal)
  315.         {
  316.                 path = PathUtil::GetGameFolder().c_str();
  317.                 path += "\\Libs\\";
  318.         }
  319.         else
  320.         {
  321.                 if (gEnv->IsEditor())
  322.                 {
  323.                         char* levelName;
  324.                         char* levelPath;
  325.                         gEnv->pGameFramework->GetEditorLevel(&levelName, &levelPath);
  326.                         path = levelPath;
  327.                 }
  328.                 else
  329.                 {
  330.                         ILevelInfo* pLevel = gEnv->pGameFramework->GetILevelSystem()->GetCurrentLevel();
  331.                         if (pLevel)
  332.                         {
  333.                                 path = pLevel->GetPath();
  334.                         }
  335.                 }
  336.         }
  337.  
  338.         if (false == path.empty())
  339.         {
  340.                 path += MODULE_FOLDER_NAME;
  341.                 ScanFolder(path, bGlobal);
  342.         }
  343. }
  344.  
  345. void CFlowGraphModuleManager::ScanForModules()
  346. {
  347.         LOADING_TIME_PROFILE_SECTION;
  348.  
  349.         // first remove any existing modules
  350.         ClearModules();
  351.  
  352.         // during scanning, modules will be PreLoaded - created, and nodes registered. This ensures that when we actually
  353.         //      load the graphs, the nodes already exist - even if one module contains the nodes relating to another module.
  354.         RescanModuleNames(true);
  355.         RescanModuleNames(false);
  356.  
  357.         // Second pass: loading the graphs, now all nodes should exist.
  358.         for (TModulesPathInfo::const_iterator it = m_ModulesPathInfo.begin(), end = m_ModulesPathInfo.end(); it != end; ++it)
  359.         {
  360.                 LoadModuleGraph(it->first, it->second, IFlowGraphModuleListener::ERootGraphChangeReason::ScanningForModules);
  361.         }
  362.  
  363.         for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  364.         {
  365.                 notifier->OnScannedForModules();
  366.         }
  367. }
  368.  
  369. bool CFlowGraphModuleManager::SaveModule(const char* moduleName, XmlNodeRef saveTo)
  370. {
  371.         TModuleId moduleId = stl::find_in_map(m_ModuleIds, moduleName, MODULEID_INVALID);
  372.         if (moduleId != MODULEID_INVALID)
  373.         {
  374.                 CFlowGraphModule* pModule = stl::find_in_map(m_Modules, moduleId, nullptr);
  375.                 if (pModule)
  376.                 {
  377.                         return pModule->SaveModuleXml(saveTo);
  378.                 }
  379.         }
  380.  
  381.         return false;
  382. }
  383.  
  384. /* Iterator */
  385. IModuleIteratorPtr CFlowGraphModuleManager::CreateModuleIterator()
  386. {
  387.         if (m_iteratorPool.empty())
  388.         {
  389.                 return new CModuleIterator(this);
  390.         }
  391.         else
  392.         {
  393.                 CModuleIterator* pIter = m_iteratorPool.back();
  394.                 m_iteratorPool.pop_back();
  395.                 new(pIter) CModuleIterator(this);
  396.                 return pIter;
  397.         }
  398. }
  399.  
  400. /* Getters/Setters */
  401.  
  402. IFlowGraphModule* CFlowGraphModuleManager::GetModule(TModuleId moduleId) const
  403. {
  404.         return stl::find_in_map(m_Modules, moduleId, NULL);
  405. }
  406.  
  407. IFlowGraphModule* CFlowGraphModuleManager::GetModule(const char* moduleName) const
  408. {
  409.         TModuleId id = stl::find_in_map(m_ModuleIds, moduleName, MODULEID_INVALID);
  410.         return GetModule(id);
  411. }
  412.  
  413. IFlowGraphModule* CFlowGraphModuleManager::GetModule(IFlowGraphPtr pFlowgraph) const
  414. {
  415.         for (TModuleMap::const_iterator it = m_Modules.begin(), end = m_Modules.end(); it != end; ++it)
  416.         {
  417.                 CFlowGraphModule* pModule = it->second;
  418.  
  419.                 if (pModule && pModule->HasInstanceGraph(pFlowgraph))
  420.                 {
  421.                         return pModule;
  422.                 }
  423.         }
  424.  
  425.         return NULL;
  426. }
  427.  
  428. const char* CFlowGraphModuleManager::GetModulePath(const char* name)
  429. {
  430.         if (m_ModulesPathInfo.empty())
  431.                 return NULL;
  432.  
  433.         TModulesPathInfo::iterator modulePathEntry = m_ModulesPathInfo.find(name);
  434.         if (m_ModulesPathInfo.end() != modulePathEntry)
  435.         {
  436.                 return modulePathEntry->second;
  437.         }
  438.  
  439.         return NULL;
  440. }
  441.  
  442. bool CFlowGraphModuleManager::AddModulePathInfo(const char* moduleName, const char* path)
  443. {
  444.         TModulesPathInfo::iterator modulePathEntry = m_ModulesPathInfo.find(moduleName);
  445.         if (m_ModulesPathInfo.end() != modulePathEntry)
  446.         {
  447.                 return false;
  448.         }
  449.  
  450.         m_ModulesPathInfo.insert(TModulesPathInfo::value_type(moduleName, path));
  451.         return true;
  452. }
  453.  
  454. const char* CFlowGraphModuleManager::GetStartNodeName(const char* moduleName) const
  455. {
  456.         static CryFixedStringT<64> temp;
  457.         temp.Format("Module:Start_%s", moduleName);
  458.         return temp.c_str();
  459. }
  460.  
  461. const char* CFlowGraphModuleManager::GetReturnNodeName(const char* moduleName) const
  462.         {
  463.         static CryFixedStringT<64> temp;
  464.         temp.Format("Module:End_%s", moduleName);
  465.         return temp.c_str();
  466.         }
  467.  
  468. const char* CFlowGraphModuleManager::GetCallerNodeName(const char* moduleName) const
  469. {
  470.         static CryFixedStringT<64> temp;
  471.         temp.Format("Module:Call_%s", moduleName);
  472.         return temp.c_str();
  473. }
  474.  
  475. /* Create Module Nodes */
  476. bool CFlowGraphModuleManager::CreateModuleNodes(const char* moduleName, TModuleId moduleId)
  477. {
  478.         assert(moduleId != MODULEID_INVALID);
  479.  
  480.         CFlowGraphModule* pModule = static_cast<CFlowGraphModule*>(GetModule(moduleId));
  481.         if (pModule)
  482.         {
  483.                 pModule->RegisterNodes();
  484.         }
  485.  
  486.         return true;
  487. }
  488.  
  489. /* Module handling */
  490. void CFlowGraphModuleManager::RemoveCompletedModuleInstances()
  491. {
  492.         for (TModuleMap::iterator it = m_Modules.begin(), end = m_Modules.end(); it != end; ++it)
  493. {
  494.                 it->second->RemoveCompletedInstances();
  495. }
  496. }
  497.  
  498. void CFlowGraphModuleManager::DestroyActiveModuleInstances()
  499. {
  500.         for (TModuleMap::const_iterator it = m_Modules.begin(), end = m_Modules.end(); it != end; ++it)
  501.         {
  502.                 if (CFlowGraphModule* pModule = it->second)
  503.                 {
  504.                         pModule->RemoveAllInstances();
  505.                         pModule->RemoveCompletedInstances();
  506.                         pModule->ClearCallNodesForInstances();
  507.                         pModule->ClearGlobalControlNodes();
  508.                 }
  509.         }
  510. }
  511.  
  512. void CFlowGraphModuleManager::ClearModuleRequestedInstances()
  513. {
  514.         for (TModuleMap::const_iterator it = m_Modules.begin(), end = m_Modules.end(); it != end; ++it)
  515. {
  516.                 if (CFlowGraphModule* pModule = it->second)
  517.         {
  518.                         pModule->ClearCallNodesForInstances();
  519.                 }
  520.         }
  521. }
  522.  
  523. bool CFlowGraphModuleManager::RegisterListener(IFlowGraphModuleListener* pListener, const char* name)
  524. {
  525.         return m_listeners.Add(pListener, name);
  526. }
  527.  
  528. void CFlowGraphModuleManager::UnregisterListener(IFlowGraphModuleListener* pListener)
  529. {
  530.         m_listeners.Remove(pListener);
  531. }
  532.  
  533. void CFlowGraphModuleManager::BroadcastModuleInstanceStarted(IFlowGraphModule* module, TModuleInstanceId instanceID)
  534. {
  535.         for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  536.         {
  537.                 notifier->OnModuleInstanceCreated(module, instanceID);
  538.         }
  539. }
  540.  
  541. void CFlowGraphModuleManager::BroadcastModuleInstanceFinished(IFlowGraphModule* module, TModuleInstanceId instanceID)
  542. {
  543.         for (CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  544.         {
  545.                 notifier->OnModuleInstanceDestroyed(module, instanceID);
  546.         }
  547. }
  548.  
  549. /* ISystemEventListener */
  550. void CFlowGraphModuleManager::OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam)
  551. {
  552.         switch (event)
  553.         {
  554.         case ESYSTEM_EVENT_LEVEL_LOAD_START:
  555.                 {
  556.                         ScanForModules();
  557.                 }
  558.                 break;
  559.         case ESYSTEM_EVENT_LEVEL_UNLOAD:
  560. {
  561.                         if (gEnv->pGameFramework->GetILevelSystem()->IsLevelLoaded())
  562.                                 ClearModules();
  563.                 }
  564.                 break;
  565.         case ESYSTEM_EVENT_EDITOR_GAME_MODE_CHANGED:
  566.         case ESYSTEM_EVENT_EDITOR_SIMULATION_MODE_CHANGED:
  567.         {
  568.                         if (wparam == 0)
  569.                 {
  570.                                 DestroyActiveModuleInstances();
  571.                         }
  572.                 }
  573.                 break;
  574.         }
  575. }
  576.  
  577. /* IGameFrameworkListener */
  578. void CFlowGraphModuleManager::OnPostUpdate(float fDeltaTime)
  579. {
  580. #if !defined (_RELEASE)
  581.         if (CV_fg_debugmodules > 0)
  582.         {
  583.                 RenderModuleDebugInfo();
  584.         }
  585. #endif
  586. }
  587.  
  588. /* Debug Draw */
  589. #if !defined (_RELEASE)
  590. void inline DrawModule2dLabel(float x, float y, float fontSize, const float* pColor, const char* pText)
  591. {
  592.         IRenderAuxText::DrawText(Vec3(x, y, 0.5f), fontSize, IRenderAuxText::AColor(pColor),
  593.                 eDrawText_2D | eDrawText_800x600 | eDrawText_FixedSize | eDrawText_Monospace, pText);
  594. }
  595.  
  596. void DrawModuleTextLabel(float x, float y, const float* pColor, const char* pFormat, ...)
  597. {
  598.         char buffer[512];
  599.  
  600.         va_list args;
  601.         va_start(args, pFormat);
  602.         cry_vsprintf(buffer, pFormat, args);
  603.         va_end(args);
  604.  
  605.         DrawModule2dLabel(x, y, 1.4f, pColor, buffer);
  606. }
  607.  
  608. void RenderModuleDebugInfo()
  609. {
  610.         CRY_ASSERT_MESSAGE(gEnv->pFlowSystem, "No Flowsystem available!");
  611.  
  612.         if (!gEnv->pFlowSystem || !gEnv->pFlowSystem->GetIModuleManager())
  613.                 return;
  614.  
  615.         IModuleIteratorPtr pIter = gEnv->pFlowSystem->GetIModuleManager()->CreateModuleIterator();
  616.         if (!pIter)
  617.                 return;
  618.  
  619.         const int count = pIter->Count();
  620.  
  621.         if (count == 0)
  622.         {
  623.                 static const float colorRed[4] = { 1.0f, 0.0f, 0.0f, 1.0f };
  624.                 DrawModuleTextLabel(10, 20, colorRed, "NO FLOWGRAPH MODULES AVAILABLE!");
  625.                 return;
  626.         }
  627.  
  628.         if (IFlowGraphModule* pModule = pIter->Next())
  629.         {
  630.                 float py = 15;
  631.                 const float dy = 15;
  632.                 const float dy_space = 5;
  633.                 static const float colorWhite[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
  634.                 static const float colorBlue[4] = { 0.3f, 0.8f, 1.0f, 1.0f };
  635.                 static const float colorGray[4] = { 0.3f, 0.3f, 0.3f, 1.0f };
  636.                 static const float colorGreen[4] = { 0.3f, 1.0f, 0.8f, 1.0f };
  637.  
  638.                 const float col1 = 10;
  639.                 const float col4 = col1 + 350;
  640.                 const float col5 = col4 + 40;
  641.  
  642.                 DrawModuleTextLabel(col1, py, colorWhite, "Module");
  643.                 DrawModuleTextLabel(col4, py, colorWhite, "Instances");
  644.  
  645.                 py += dy + dy_space;
  646.  
  647.                 for (int i = 0; i < count; ++i)
  648.                 {
  649.                         // skip this module if the filter is being used and it's not there
  650.                         string filter = gEnv->pConsole->GetCVar("fg_debugmodules_filter")->GetString();
  651.                         string moduleName = pModule->GetName();
  652.                         moduleName.MakeLower();
  653.                         filter.MakeLower();
  654.                         if (!filter.empty() && moduleName.find(filter) == string::npos)
  655.                         {
  656.                                 pModule = pIter->Next();
  657.                                 continue;
  658.                         }
  659.  
  660.                         // module details
  661.                         const int runningInstances = pModule->GetRunningInstancesCount();
  662.  
  663.                         DrawModuleTextLabel(col1, py, runningInstances ? colorBlue : colorGray, "%s", pModule->GetName());
  664.                         DrawModuleTextLabel(col4, py, runningInstances ? colorGreen : colorGray, "%d", runningInstances);
  665.  
  666.                         // instances' details
  667.                         if (CFlowGraphModuleManager::CV_fg_debugmodules == 2 && runningInstances > 0)
  668.                         {
  669.                                 IModuleInstanceIteratorPtr instanceIter = pModule->CreateInstanceIterator();
  670.                                 if (!instanceIter)
  671.                                 {
  672.                                         continue;
  673.                                 }
  674.  
  675.                                 DrawModuleTextLabel(col5, py, colorWhite, "IDs:");
  676.                                 stack_string s_idList("");
  677.                                 for (IModuleInstance* pInstance = instanceIter->Next(); pInstance; pInstance = instanceIter->Next())
  678.                                         {
  679.                                         if (!pInstance->m_bUsed)
  680.                                                 {
  681.                                                 continue;
  682.                                                 }
  683.                                         EntityId entityId = static_cast<SModuleInstance*>(pInstance)->m_entityId;
  684.                                         stack_string s_inst;
  685.                                         if (entityId != INVALID_ENTITYID)
  686.                                         {
  687.                                                 s_inst.Format(", %d (Entity %u)", (pInstance->m_instanceId != MODULEINSTANCE_INVALID ? pInstance->m_instanceId : -1), entityId);
  688.                                         }
  689.                                 else
  690.                                 {
  691.                                                 s_inst.Format(", %u", pInstance->m_instanceId);
  692.                                         }
  693.                                         s_idList.append(s_inst.c_str());
  694.                                 }
  695.                                 DrawModuleTextLabel(col5 + 40, py, colorGreen, "%s", s_idList.size() > 2 ? s_idList.c_str() + 2 : "-");
  696.                         }
  697.  
  698.                         py += dy;
  699.                         pModule = pIter->Next();
  700.                 }
  701.         }
  702. }
  703. #endif
  704.  
downloadModuleManager.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