BVB Source Codes

CRYENGINE Show ItemParams.cpp Source code

Return Download CRYENGINE: download ItemParams.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.  
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 18:8:2005   17:27 : Created by M谩rcio Martins
  11.  
  12. *************************************************************************/
  13. #include "StdAfx.h"
  14. #include "ItemParams.h"
  15.  
  16. //------------------------------------------------------------------------
  17. //int g_paramNodeDebugCount = 0;
  18.  
  19. CItemParamsNode::CItemParamsNode()
  20.         : m_refs(1)
  21. {
  22.         //g_paramNodeDebugCount++;
  23. };
  24.  
  25. //------------------------------------------------------------------------
  26. CItemParamsNode::~CItemParamsNode()
  27. {
  28.         for (TChildVector::iterator it = m_children.begin(); it != m_children.end(); ++it)
  29.                 delete (*it);
  30.  
  31.         //g_paramNodeDebugCount--;
  32. }
  33.  
  34. //------------------------------------------------------------------------
  35. int CItemParamsNode::GetAttributeCount() const
  36. {
  37.         return m_attributes.size();
  38. }
  39.  
  40. //------------------------------------------------------------------------
  41. const char* CItemParamsNode::GetAttributeName(int i) const
  42. {
  43.         TAttributeMap::const_iterator it = GetConstIterator<TAttributeMap>(m_attributes, i);
  44.         if (it != m_attributes.end())
  45.                 return it->first.c_str();
  46.         return 0;
  47. }
  48.  
  49. //------------------------------------------------------------------------
  50. const char* CItemParamsNode::GetAttribute(int i) const
  51. {
  52.         TAttributeMap::const_iterator it = GetConstIterator<TAttributeMap>(m_attributes, i);
  53.         if (it != m_attributes.end())
  54.         {
  55.                 const string* str = it->second.GetPtr<string>();
  56.                 return str ? str->c_str() : 0;
  57.         }
  58.         return 0;
  59. }
  60.  
  61. //------------------------------------------------------------------------
  62. bool CItemParamsNode::GetAttribute(int i, Vec3& attr) const
  63. {
  64.         TAttributeMap::const_iterator it = GetConstIterator<TAttributeMap>(m_attributes, i);
  65.         if (it != m_attributes.end())
  66.                 return it->second.GetValueWithConversion(attr);
  67.         return false;
  68. }
  69.  
  70. //------------------------------------------------------------------------
  71. bool CItemParamsNode::GetAttribute(int i, Ang3& attr) const
  72. {
  73.         Vec3 temp;
  74.         bool r = GetAttribute(i, temp);
  75.         attr = Ang3(temp);
  76.         return r;
  77. }
  78.  
  79. //------------------------------------------------------------------------
  80. bool CItemParamsNode::GetAttribute(int i, float& attr) const
  81. {
  82.         TAttributeMap::const_iterator it = GetConstIterator<TAttributeMap>(m_attributes, i);
  83.         if (it != m_attributes.end())
  84.                 return it->second.GetValueWithConversion(attr);
  85.         return false;
  86. }
  87.  
  88. //------------------------------------------------------------------------
  89. bool CItemParamsNode::GetAttribute(int i, int& attr) const
  90. {
  91.         TAttributeMap::const_iterator it = GetConstIterator<TAttributeMap>(m_attributes, i);
  92.         if (it != m_attributes.end())
  93.                 return it->second.GetValueWithConversion(attr);
  94.         return false;
  95. }
  96.  
  97. //------------------------------------------------------------------------
  98. int CItemParamsNode::GetAttributeType(int i) const
  99. {
  100.         TAttributeMap::const_iterator it = GetConstIterator<TAttributeMap>(m_attributes, i);
  101.         if (it != m_attributes.end())
  102.                 return it->second.GetType();
  103.         return eIPT_None;
  104. }
  105.  
  106. //------------------------------------------------------------------------
  107. const char* CItemParamsNode::GetNameAttribute() const
  108. {
  109.         return m_nameAttribute.c_str();
  110. }
  111.  
  112. //------------------------------------------------------------------------
  113. const char* CItemParamsNode::GetAttribute(const char* name) const
  114. {
  115.         TAttributeMap::const_iterator it = FindAttrIterator(m_attributes, name);
  116.         if (it != m_attributes.end())
  117.         {
  118.                 const string* str = it->second.GetPtr<string>();
  119.                 return str ? str->c_str() : 0;
  120.         }
  121.         return 0;
  122. }
  123.  
  124. //------------------------------------------------------------------------
  125. const char* CItemParamsNode::GetAttributeSafe(const char* name) const
  126. {
  127.         TAttributeMap::const_iterator it = FindAttrIterator(m_attributes, name);
  128.         if (it != m_attributes.end())
  129.         {
  130.                 const string* str = it->second.GetPtr<string>();
  131.                 return str ? str->c_str() : "";
  132.         }
  133.         return "";
  134. }
  135.  
  136. //------------------------------------------------------------------------
  137. bool CItemParamsNode::GetAttribute(const char* name, Vec3& attr) const
  138. {
  139.         TAttributeMap::const_iterator it = FindAttrIterator(m_attributes, name);
  140.         if (it != m_attributes.end())
  141.                 return it->second.GetValueWithConversion(attr);
  142.         return false;
  143. }
  144.  
  145. //------------------------------------------------------------------------
  146. bool CItemParamsNode::GetAttribute(const char* name, Ang3& attr) const
  147. {
  148.         Vec3 temp;
  149.         bool r = GetAttribute(name, temp);
  150.         if (r)
  151.                 attr = Ang3(temp);
  152.         return r;
  153. }
  154.  
  155. //------------------------------------------------------------------------
  156. bool CItemParamsNode::GetAttribute(const char* name, float& attr) const
  157. {
  158.         TAttributeMap::const_iterator it = FindAttrIterator(m_attributes, name);
  159.         if (it != m_attributes.end())
  160.                 return it->second.GetValueWithConversion(attr);
  161.         return false;
  162. }
  163.  
  164. //------------------------------------------------------------------------
  165. bool CItemParamsNode::GetAttribute(const char* name, int& attr) const
  166. {
  167.         TAttributeMap::const_iterator it = FindAttrIterator(m_attributes, name);
  168.         if (it != m_attributes.end())
  169.                 return it->second.GetValueWithConversion(attr);
  170.         return false;
  171. }
  172.  
  173. //------------------------------------------------------------------------
  174. int CItemParamsNode::GetAttributeType(const char* name) const
  175. {
  176.         TAttributeMap::const_iterator it = FindAttrIterator(m_attributes, name);
  177.         if (it != m_attributes.end())
  178.                 return it->second.GetType();
  179.         return eIPT_None;
  180. }
  181.  
  182. //------------------------------------------------------------------------
  183. int CItemParamsNode::GetChildCount() const
  184. {
  185.         return (int)m_children.size();
  186. }
  187.  
  188. //------------------------------------------------------------------------
  189. const char* CItemParamsNode::GetChildName(int i) const
  190. {
  191.         if (i >= 0 && i < m_children.size())
  192.                 return m_children[i]->GetName();
  193.         return 0;
  194. }
  195.  
  196. //------------------------------------------------------------------------
  197. const IItemParamsNode* CItemParamsNode::GetChild(int i) const
  198. {
  199.         if (i >= 0 && i < m_children.size())
  200.                 return m_children[i];
  201.         return 0;
  202. }
  203.  
  204. //------------------------------------------------------------------------
  205. const IItemParamsNode* CItemParamsNode::GetChild(const char* name) const
  206. {
  207.         for (TChildVector::const_iterator it = m_children.begin(); it != m_children.end(); ++it)
  208.         {
  209.                 if (!strcmpi((*it)->GetName(), name))
  210.                         return (*it);
  211.         }
  212.         return 0;
  213. }
  214.  
  215. //------------------------------------------------------------------------
  216. void CItemParamsNode::SetAttribute(const char* name, const char* attr)
  217. {
  218.         //m_attributes.insert(TAttributeMap::value_type(name, string(attr)));
  219.         if (!strcmpi(name, "name"))
  220.         {
  221.                 m_nameAttribute = attr;
  222.                 AddAttribute(name, TItemParamValue(m_nameAttribute));
  223.         }
  224.         else
  225.                 AddAttribute(name, TItemParamValue(string(attr)));
  226. }
  227.  
  228. //------------------------------------------------------------------------
  229. void CItemParamsNode::SetAttribute(const char* name, const Vec3& attr)
  230. {
  231.         //m_attributes.insert(TAttributeMap::value_type(name, attr));
  232.         AddAttribute(name, TItemParamValue(attr));
  233. }
  234.  
  235. //------------------------------------------------------------------------
  236. void CItemParamsNode::SetAttribute(const char* name, float attr)
  237. {
  238.         //m_attributes.insert(TAttributeMap::value_type(name, attr));
  239.         AddAttribute(name, TItemParamValue(attr));
  240. }
  241.  
  242. //------------------------------------------------------------------------
  243. void CItemParamsNode::SetAttribute(const char* name, int attr)
  244. {
  245.         //m_attributes.insert(TAttributeMap::value_type(name, attr));
  246.         AddAttribute(name, TItemParamValue(attr));
  247. }
  248.  
  249. //------------------------------------------------------------------------
  250. IItemParamsNode* CItemParamsNode::InsertChild(const char* name)
  251. {
  252.         m_children.push_back(new CItemParamsNode());
  253.         IItemParamsNode* inserted = m_children.back();
  254.         inserted->SetName(name);
  255.         return inserted;
  256. }
  257.  
  258. //------------------------------------------------------------------------
  259. bool IsInteger(const char* v, int* i = 0)
  260. {
  261.         errno = 0;
  262.         char* endptr = 0;
  263.         int r = strtol(v, &endptr, 0);
  264.         if (errno && (errno != ERANGE))
  265.                 return false;
  266.         if (endptr == v || *endptr != '\0')
  267.                 return false;
  268.         if (i)
  269.                 *i = r;
  270.         return true;
  271. }
  272.  
  273. //------------------------------------------------------------------------
  274. bool IsFloat(const char* v, float* f = 0)
  275. {
  276.         errno = 0;
  277.         char* endptr = 0;
  278.         float r = (float)strtod(v, &endptr);
  279.         if (errno && (errno != ERANGE))
  280.                 return false;
  281.         if (endptr == v || *endptr != '\0')
  282.                 return false;
  283.         if (f)
  284.                 *f = r;
  285.         return true;
  286. }
  287.  
  288. //------------------------------------------------------------------------
  289. bool IsVec3(const char* v, Vec3* vec)
  290. {
  291.         float x, y, z;
  292.         if (sscanf(v, "%f,%f,%f", &x, &y, &z) != 3)
  293.                 return false;
  294.         if (vec)
  295.                 vec->Set(x, y, z);
  296.         return true;
  297. }
  298.  
  299. //------------------------------------------------------------------------
  300. void CItemParamsNode::ConvertFromXML(const XmlNodeRef& root)
  301. {
  302.         if (gEnv->bMultiplayer)
  303.         {
  304.                 ConvertFromXMLWithFiltering(root, "MP");
  305.         }
  306.         else
  307.         {
  308.                 ConvertFromXMLWithFiltering(root, "SP");
  309.         }
  310. }
  311.  
  312. bool CItemParamsNode::ConvertFromXMLWithFiltering(const XmlNodeRef& root, const char* keepWithThisAttrValue)
  313. {
  314.         bool filteringRequired = false;
  315.         int nattributes = root->getNumAttributes();
  316.         m_attributes.reserve(nattributes);
  317.         for (int a = 0; a < nattributes; a++)
  318.         {
  319.                 const char* name = 0;
  320.                 const char* value = 0;
  321.                 if (root->getAttributeByIndex(a, &name, &value))
  322.                 {
  323.                         float f;
  324.                         int i;
  325.                         Vec3 v;
  326.                         if (!stricmp(value, "true"))
  327.                                 SetAttribute(name, 1);
  328.                         else if (!stricmp(value, "false"))
  329.                                 SetAttribute(name, 0);
  330.                         else if (IsInteger(value, &i))
  331.                                 SetAttribute(name, i);
  332.                         else if (IsFloat(value, &f))
  333.                                 SetAttribute(name, f);
  334.                         else if (IsVec3(value, &v))
  335.                                 SetAttribute(name, v);
  336.                         else
  337.                                 SetAttribute(name, value);
  338.                 }
  339.         }
  340.  
  341.         int nchildren = root->getChildCount();
  342.         m_children.reserve(nchildren);
  343.         for (int c = 0; c < nchildren; c++)
  344.         {
  345.                 XmlNodeRef child = root->getChild(c);
  346.                 EXMLFilterType filterType = ShouldConvertNodeFromXML(child, keepWithThisAttrValue);
  347.                 filteringRequired = (filterType != eXMLFT_none) || filteringRequired ? true : false;
  348.  
  349.                 if (filterType != eXMLFT_remove)
  350.                 {
  351.                         filteringRequired = (InsertChild(child->getTag())->ConvertFromXMLWithFiltering(child, keepWithThisAttrValue) || filteringRequired);
  352.                 }
  353.         }
  354.  
  355.         return filteringRequired;
  356. }
  357.  
  358. CItemParamsNode::EXMLFilterType CItemParamsNode::ShouldConvertNodeFromXML(const XmlNodeRef& xmlNode, const char* keepWithThisAttrValue) const
  359. {
  360.         if (xmlNode->haveAttr("GAME"))
  361.         {
  362.                 const char* game = xmlNode->getAttr("GAME");
  363.  
  364.                 return (strcmp(game, keepWithThisAttrValue) == 0 ? eXMLFT_add : eXMLFT_remove);
  365.         }
  366.  
  367.         return eXMLFT_none;
  368. }
  369.  
  370. void CItemParamsNode::GetMemoryUsage(ICrySizer* pSizer) const
  371. {
  372.         pSizer->AddObject(this, sizeof(*this));
  373.         pSizer->AddObject(m_name);
  374.         pSizer->AddObject(m_nameAttribute);
  375.         pSizer->AddContainer(m_attributes);
  376.         pSizer->AddContainer(m_children);
  377. }
  378.  
downloadItemParams.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