BVB Source Codes

CRYENGINE Show OpticsManager.cpp Source code

Return Download CRYENGINE: download OpticsManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. //////////////////////////////////////////////////////////////////////
  5.  
  6. #include "StdAfx.h"
  7. #include "OpticsManager.h"
  8.  
  9. void COpticsManager::Reset()
  10. {
  11.         m_OpticsMap.clear();
  12.         m_SearchedOpticsSet.clear();
  13.  
  14.         for (auto& pOpticsElement : m_OpticsList)
  15.                 gEnv->pRenderer->ReleaseOptics(pOpticsElement);
  16.  
  17.         stl::free_container(m_OpticsList);
  18. }
  19.  
  20. IOpticsElementBase* COpticsManager::Create(EFlareType type) const
  21. {
  22.         return gEnv->pRenderer->CreateOptics(type);
  23. }
  24.  
  25. IOpticsElementBase* COpticsManager::ParseOpticsRecursively(IOpticsElementBase* pParentOptics, XmlNodeRef& node) const
  26. {
  27.         const char* type;
  28.         if (!node->getAttr("Type", &type))
  29.                 return NULL;
  30.  
  31.         if (!gEnv->pRenderer)
  32.                 return NULL;
  33.  
  34.         IOpticsElementBase* pOptics = Create(GetFlareType(type));
  35.         if (pOptics == NULL)
  36.                 return NULL;
  37.  
  38.         bool bEnable(false);
  39.         node->getAttr("Enable", bEnable);
  40.         pOptics->SetEnabled(bEnable);
  41.  
  42.         const char* name;
  43.         if (node->getAttr("Name", &name))
  44.                 pOptics->SetName(name);
  45.  
  46.         if (pParentOptics)
  47.                 pParentOptics->AddElement(pOptics);
  48.  
  49.         for (int i = 0, iChildCount(node->getChildCount()); i < iChildCount; ++i)
  50.         {
  51.                 XmlNodeRef pChild = node->getChild(i);
  52.                 if (pChild == (IXmlNode*)NULL)
  53.                         continue;
  54.  
  55.                 if (!stricmp(pChild->getTag(), "Params"))
  56.                 {
  57.                         pOptics->Load(pChild);
  58.                 }
  59.                 else if (!stricmp(pChild->getTag(), "FlareItem"))
  60.                 {
  61.                         ParseOpticsRecursively(pOptics, pChild);
  62.                 }
  63.         }
  64.  
  65.         return pOptics;
  66. }
  67.  
  68. bool COpticsManager::Load(const char* fullFlareName, int& nOutIndex)
  69. {
  70.         int nOpticsIndex = FindOpticsIndex(fullFlareName);
  71.         if (nOpticsIndex >= 0)
  72.         {
  73.                 nOutIndex = nOpticsIndex;
  74.                 return true;
  75.         }
  76.  
  77.         string strFullFlareName(fullFlareName);
  78.         int nPos = strFullFlareName.find(".");
  79.         if (nPos == -1)
  80.                 return false;
  81.  
  82.         string xmlFileName = strFullFlareName.substr(0, nPos);
  83.  
  84.         int restLength = strFullFlareName.length() - nPos - 1;
  85.         if (restLength <= 0)
  86.                 return false;
  87.  
  88.         if (m_SearchedOpticsSet.find(fullFlareName) != m_SearchedOpticsSet.end())
  89.                 return false;
  90.  
  91.         string fullPath = gEnv->pCryPak->GetGameFolder() + string("/") + string(FLARE_LIBS_PATH) + xmlFileName + ".xml";
  92.         XmlNodeRef rootNode = gEnv->pSystem->LoadXmlFromFile(fullPath.c_str());
  93.  
  94.         if (rootNode == (IXmlNode*)NULL)
  95.                 return false;
  96.  
  97.         MEMSTAT_CONTEXT_FMT(EMemStatContextTypes::MSC_Other, 0, "%s", fullFlareName);
  98.  
  99.         string opticsLibName = strFullFlareName.substr(nPos + 1, restLength);
  100.         m_SearchedOpticsSet.insert(fullFlareName);
  101.  
  102.         for (int i = 0, iChildCount(rootNode->getChildCount()); i < iChildCount; ++i)
  103.         {
  104.                 XmlNodeRef childNode = rootNode->getChild(i);
  105.                 if (childNode == (IXmlNode*)NULL)
  106.                         continue;
  107.                 const char* name;
  108.                 if (!childNode->getAttr("Name", &name))
  109.                         continue;
  110.                 if (stricmp(name, opticsLibName.c_str()))
  111.                         continue;
  112.                 IOpticsElementBase* pOptics = ParseOpticsRecursively(NULL, childNode);
  113.                 if (pOptics == NULL)
  114.                         return false;
  115.                 return AddOptics(pOptics, fullFlareName, nOutIndex);
  116.         }
  117.  
  118.         return false;
  119. }
  120.  
  121. bool COpticsManager::Load(XmlNodeRef& rootNode, int& nOutIndex)
  122. {
  123.         const char* name = NULL;
  124.         if ((rootNode == (IXmlNode*)NULL) || (!rootNode->getAttr("Name", &name)))
  125.                 return false;
  126.  
  127.         const char* libName = NULL;
  128.         if (!rootNode->getAttr("Library", &libName))
  129.                 return false;
  130.  
  131.         IOpticsElementBase* pOptics = ParseOpticsRecursively(NULL, rootNode);
  132.         if (pOptics == NULL)
  133.                 return false;
  134.  
  135.         string fullFlareName = libName + string(".") + name;
  136.         return AddOptics(pOptics, fullFlareName, nOutIndex);
  137. }
  138.  
  139. EFlareType COpticsManager::GetFlareType(const char* typeStr) const
  140. {
  141.         if (typeStr == NULL)
  142.                 return eFT__Base__;
  143.  
  144.         const FlareInfoArray::Props array = FlareInfoArray::Get();
  145.         for (size_t i = 0; i < array.size; ++i)
  146.         {
  147.                 if (!stricmp(array.p[i].name, typeStr))
  148.                         return array.p[i].type;
  149.         }
  150.  
  151.         return eFT__Base__;
  152. }
  153.  
  154. int COpticsManager::FindOpticsIndex(const char* fullFlareName) const
  155. {
  156.         std::map<string, int>::const_iterator iOptics = m_OpticsMap.find(CONST_TEMP_STRING(fullFlareName));
  157.         if (iOptics != m_OpticsMap.end())
  158.                 return iOptics->second;
  159.         return -1;
  160. }
  161.  
  162. IOpticsElementBase* COpticsManager::GetOptics(int nIndex)
  163. {
  164.         if ((size_t)nIndex >= m_OpticsList.size())
  165.                 return NULL;
  166.         return m_OpticsList[nIndex];
  167. }
  168.  
  169. bool COpticsManager::AddOptics(IOpticsElementBase* pOptics, const char* name, int& nOutNewIndex)
  170. {
  171.         if (name == NULL)
  172.                 return false;
  173.         if (m_OpticsMap.find(name) != m_OpticsMap.end())
  174.                 return false;
  175.         nOutNewIndex = (int)m_OpticsList.size();
  176.         m_OpticsList.push_back(pOptics);
  177.         m_OpticsMap[name] = nOutNewIndex;
  178.         return true;
  179. }
  180.  
  181. bool COpticsManager::Rename(const char* fullFlareName, const char* newFullFlareName)
  182. {
  183.         if (m_OpticsMap.find(newFullFlareName) != m_OpticsMap.end())
  184.                 return true;
  185.  
  186.         std::map<string, int>::iterator iOptics = m_OpticsMap.find(fullFlareName);
  187.         if (iOptics == m_OpticsMap.end())
  188.                 return false;
  189.  
  190.         int nOpticsIndex = iOptics->second;
  191.         if (nOpticsIndex < 0 || nOpticsIndex >= (int)m_OpticsList.size())
  192.                 return false;
  193.  
  194.         m_OpticsMap.erase(iOptics);
  195.  
  196.         IOpticsElementBasePtr pOptics = m_OpticsList[nOpticsIndex];
  197.         pOptics->SetName(newFullFlareName);
  198.         m_OpticsMap[newFullFlareName] = nOpticsIndex;
  199.  
  200.         return true;
  201. }
  202.  
  203. void COpticsManager::GetMemoryUsage(ICrySizer* pSizer) const
  204. {
  205.         for (int i = 0, iSize(m_OpticsList.size()); i < iSize; ++i)
  206.                 m_OpticsList[i]->GetMemoryUsage(pSizer);
  207. }
  208.  
  209. void COpticsManager::Invalidate()
  210. {
  211.         for (int i = 0, iSize(m_OpticsList.size()); i < iSize; ++i)
  212.                 m_OpticsList[i]->Invalidate();
  213. }
  214.  
downloadOpticsManager.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