BVB Source Codes

CRYENGINE Show TagDefinitionXml.cpp Source code

Return Download CRYENGINE: download TagDefinitionXml.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 "TagDefinitionXml.h"
  5.  
  6. #include "ICryMannequin.h"
  7.  
  8. //////////////////////////////////////////////////////////////////////////
  9. #ifndef _RELEASE
  10.         #define RECURSIVE_IMPORT_CHECK (1)
  11. #else
  12.         #define RECURSIVE_IMPORT_CHECK (0)
  13. #endif
  14.  
  15. #if RECURSIVE_IMPORT_CHECK
  16. typedef std::vector<string> TRecursiveGuardList;
  17. #endif
  18. typedef std::vector<string> TImportsList;
  19.  
  20. //////////////////////////////////////////////////////////////////////////
  21. namespace mannequin
  22. {
  23. int GetTagDefinitionVersion(XmlNodeRef pXmlNode);
  24. bool LoadTagDefinitionImpl(const char* const filename, CTagDefinition & tagDefinitionOut,
  25. #if RECURSIVE_IMPORT_CHECK
  26.                            TRecursiveGuardList & recursiveGuardListOut,
  27. #endif
  28.                            STagDefinitionImportsInfo & importsInfo);
  29.  
  30. XmlNodeRef SaveTagDefinitionImpl(const CTagDefinition& tagDefinition, const TImportsList& importsList);
  31.  
  32. namespace impl
  33. {
  34. std::map<uint32, STagDefinitionImportsInfo> g_defaultImportInfo;
  35.  
  36. bool LoadTagDefinitionImplXml(XmlNodeRef pXmlNode, CTagDefinition & tagDefinitionOut,
  37. #if RECURSIVE_IMPORT_CHECK
  38.                               TRecursiveGuardList & recursiveGuardListOut,
  39. #endif
  40.                               STagDefinitionImportsInfo & importsInfo);
  41. }
  42. }
  43.  
  44. //////////////////////////////////////////////////////////////////////////
  45. STagDefinitionImportsInfo& mannequin::GetDefaultImportsInfo(const char* const filename)
  46. {
  47.         assert(filename);
  48.         assert(filename[0]);
  49.  
  50.         const uint32 crc = CCrc32::ComputeLowercase(filename);
  51.         STagDefinitionImportsInfo& importsInfo = impl::g_defaultImportInfo[crc];
  52.         importsInfo.SetFilename(filename);
  53.         return importsInfo;
  54. }
  55.  
  56. //////////////////////////////////////////////////////////////////////////
  57. void mannequin::OnDatabaseManagerUnload()
  58. {
  59.         impl::g_defaultImportInfo.clear();
  60. }
  61.  
  62. //////////////////////////////////////////////////////////////////////////
  63. template<int version>
  64. struct STagDefinitionXml
  65. {
  66. };
  67.  
  68. //////////////////////////////////////////////////////////////////////////
  69. template<>
  70. struct STagDefinitionXml<1>
  71. {
  72.         static bool Load(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut,
  73. #if RECURSIVE_IMPORT_CHECK
  74.                          TRecursiveGuardList&,
  75. #endif
  76.                          STagDefinitionImportsInfo& importsInfo)
  77.         {
  78.                 assert(pXmlNode != 0);
  79.                 const int childCount = pXmlNode->getChildCount();
  80.                 for (int i = 0; i < childCount; ++i)
  81.                 {
  82.                         XmlNodeRef pXmlChildNode = pXmlNode->getChild(i);
  83.                         LoadTagOrGroupNode(pXmlChildNode, tagDefinitionOut, importsInfo);
  84.                 }
  85.                 return true;
  86.         }
  87.  
  88.         static void Save(XmlNodeRef pXmlNode, const CTagDefinition& tagDefinition)
  89.         {
  90.                 assert(pXmlNode != 0);
  91.                 pXmlNode->setAttr("version", 1);
  92.  
  93.                 std::vector<XmlNodeRef> groupXmlNodes;
  94.  
  95.                 const TagGroupID groupCount = tagDefinition.GetNumGroups();
  96.                 groupXmlNodes.resize(groupCount);
  97.                 for (TagGroupID i = 0; i < groupCount; ++i)
  98.                 {
  99.                         const char* const groupName = tagDefinition.GetGroupName(i);
  100.                         XmlNodeRef pXmlTagGroup = pXmlNode->createNode(groupName);
  101.                         pXmlNode->addChild(pXmlTagGroup);
  102.  
  103.                         groupXmlNodes[i] = pXmlTagGroup;
  104.                 }
  105.  
  106.                 const TagID tagCount = tagDefinition.GetNum();
  107.                 for (TagID i = 0; i < tagCount; ++i)
  108.                 {
  109.                         const char* const tagName = tagDefinition.GetTagName(i);
  110.                         XmlNodeRef pXmlTag = pXmlNode->createNode(tagName);
  111.  
  112.                         const uint32 tagPriority = tagDefinition.GetPriority(i);
  113.                         if (tagPriority != 0)
  114.                         {
  115.                                 pXmlTag->setAttr("priority", tagPriority);
  116.                         }
  117.  
  118.                         const TagGroupID groupId = tagDefinition.GetGroupID(i);
  119.                         if (groupId == GROUP_ID_NONE)
  120.                         {
  121.                                 pXmlNode->addChild(pXmlTag);
  122.                         }
  123.                         else
  124.                         {
  125.                                 XmlNodeRef pXmlTagGroup = groupXmlNodes[groupId];
  126.                                 pXmlTagGroup->addChild(pXmlTag);
  127.                         }
  128.                 }
  129.         }
  130.  
  131. private:
  132.         static void LoadTagOrGroupNode(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  133.         {
  134.                 assert(pXmlNode != 0);
  135.                 const int childCount = pXmlNode->getChildCount();
  136.                 const bool isGroupNode = (childCount != 0);
  137.                 if (isGroupNode)
  138.                 {
  139.                         LoadGroupNode(pXmlNode, childCount, tagDefinitionOut, importsInfo);
  140.                 }
  141.                 else
  142.                 {
  143.                         LoadTagNode(pXmlNode, NULL, tagDefinitionOut, importsInfo);
  144.                 }
  145.         }
  146.  
  147.         static void LoadTagNode(XmlNodeRef pXmlNode, const char* const groupName, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  148.         {
  149.                 assert(pXmlNode != 0);
  150.  
  151.                 uint32 priority = 0;
  152.                 pXmlNode->getAttr("priority", priority);
  153.                 const char* const tagName = pXmlNode->getTag();
  154.  
  155.                 const TagID tagId = tagDefinitionOut.AddTag(tagName, groupName, priority);
  156.                 if (tagId == TAG_ID_INVALID)
  157.                 {
  158.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Duplicate tag '%s'", tagName);
  159.                         // We will continue loading
  160.                 }
  161.  
  162.                 importsInfo.AddTag(tagId);
  163.         }
  164.  
  165.         static void LoadGroupNode(XmlNodeRef pXmlNode, const int childCount, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  166.         {
  167.                 assert(pXmlNode != 0);
  168.                 assert(pXmlNode->getChildCount() == childCount);
  169.  
  170.                 const char* const groupName = pXmlNode->getTag();
  171.                 for (int i = 0; i < childCount; ++i)
  172.                 {
  173.                         XmlNodeRef pXmlChildNode = pXmlNode->getChild(i);
  174.                         LoadTagNode(pXmlChildNode, groupName, tagDefinitionOut, importsInfo);
  175.                 }
  176.         }
  177. };
  178.  
  179. //////////////////////////////////////////////////////////////////////////
  180. template<>
  181. struct STagDefinitionXml<2>
  182. {
  183.         static bool Load(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut,
  184. #if RECURSIVE_IMPORT_CHECK
  185.                          TRecursiveGuardList& recursiveGuardListOut,
  186. #endif
  187.                          STagDefinitionImportsInfo& importsInfo)
  188.         {
  189.                 assert(pXmlNode != 0);
  190.  
  191.                 XmlNodeRef pXmlImportsNode = pXmlNode->findChild("Imports");
  192.                 const bool importsLoadSuccess = LoadImportsNode(pXmlImportsNode, tagDefinitionOut,
  193. #if RECURSIVE_IMPORT_CHECK
  194.                                                                 recursiveGuardListOut,
  195. #endif
  196.                                                                 importsInfo);
  197.                 if (!importsLoadSuccess)
  198.                 {
  199.                         return false;
  200.                 }
  201.  
  202.                 XmlNodeRef pXmlTagsNode = pXmlNode->findChild("Tags");
  203.                 const bool loadTagsSuccess = LoadTagsNode(pXmlTagsNode, tagDefinitionOut, importsInfo);
  204.                 return loadTagsSuccess;
  205.         }
  206.  
  207.         static void Save(XmlNodeRef pXmlNode, const CTagDefinition& tagDefinition, const TImportsList& importsList)
  208.         {
  209.                 pXmlNode->setAttr("version", 2);
  210.  
  211.                 SaveImportsNode(pXmlNode, importsList);
  212.                 SaveTagsNode(pXmlNode, tagDefinition);
  213.         }
  214.  
  215. private:
  216.         static bool LoadImportsNode(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut,
  217. #if RECURSIVE_IMPORT_CHECK
  218.                                     TRecursiveGuardList& recursiveGuardListOut,
  219. #endif
  220.                                     STagDefinitionImportsInfo& importsInfo)
  221.         {
  222.                 if (!pXmlNode)
  223.                 {
  224.                         return true;
  225.                 }
  226.  
  227.                 const int childCount = pXmlNode->getChildCount();
  228.                 for (int i = 0; i < childCount; ++i)
  229.                 {
  230.                         XmlNodeRef pXmlChildNode = pXmlNode->getChild(i);
  231.                         const bool loadSuccess = LoadImportNode(pXmlChildNode, tagDefinitionOut,
  232. #if RECURSIVE_IMPORT_CHECK
  233.                                                                 recursiveGuardListOut,
  234. #endif
  235.                                                                 importsInfo);
  236.                         if (!loadSuccess)
  237.                         {
  238.                                 return false;
  239.                         }
  240.                 }
  241.                 return true;
  242.         }
  243.  
  244.         static bool LoadImportNode(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut,
  245. #if RECURSIVE_IMPORT_CHECK
  246.                                    TRecursiveGuardList& recursiveGuardListOut,
  247. #endif
  248.                                    STagDefinitionImportsInfo& importsInfo)
  249.         {
  250.                 assert(pXmlNode != 0);
  251.  
  252.                 const char* const filename = pXmlNode->getAttr("filename");
  253.                 if (!filename)
  254.                 {
  255.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Tag definition failed to find 'filename' attribute in an 'Import' node.");
  256.                         return false;
  257.                 }
  258.  
  259.                 STagDefinitionImportsInfo& subImportsInfo = importsInfo.AddImport(filename);
  260.                 const bool loadImportedTagDefinitionSuccess = mannequin::LoadTagDefinitionImpl(filename, tagDefinitionOut,
  261. #if RECURSIVE_IMPORT_CHECK
  262.                                                                                                recursiveGuardListOut,
  263. #endif
  264.                                                                                                subImportsInfo);
  265.                 return loadImportedTagDefinitionSuccess;
  266.         }
  267.  
  268.         static bool LoadTagsNode(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  269.         {
  270.                 if (!pXmlNode)
  271.                 {
  272.                         return true;
  273.                 }
  274.                 const int childCount = pXmlNode->getChildCount();
  275.  
  276.                 bool loadSuccess = true;
  277.                 for (int i = 0; i < childCount; ++i)
  278.                 {
  279.                         XmlNodeRef pXmlChildNode = pXmlNode->getChild(i);
  280.                         loadSuccess &= LoadTagOrGroupNode(pXmlChildNode, tagDefinitionOut, importsInfo);
  281.                 }
  282.  
  283.                 return loadSuccess;
  284.         }
  285.  
  286.         static bool LoadTagOrGroupNode(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  287.         {
  288.                 assert(pXmlNode != 0);
  289.                 const int childCount = pXmlNode->getChildCount();
  290.                 const bool isGroupNode = (childCount != 0);
  291.                 if (isGroupNode)
  292.                 {
  293.                         const bool loadGroupSuccess = LoadGroupNode(pXmlNode, childCount, tagDefinitionOut, importsInfo);
  294.                         return loadGroupSuccess;
  295.                 }
  296.                 else
  297.                 {
  298.                         const bool loadTagSuccess = LoadTagNode(pXmlNode, NULL, tagDefinitionOut, importsInfo);
  299.                         return loadTagSuccess;
  300.                 }
  301.         }
  302.  
  303.         static bool LoadTagNode(XmlNodeRef pXmlNode, const char* const groupName, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  304.         {
  305.                 assert(pXmlNode != 0);
  306.  
  307.                 uint32 priority = 0;
  308.                 pXmlNode->getAttr("priority", priority);
  309.  
  310.                 const char* const tagName = pXmlNode->getAttr("name");
  311.                 if (!tagName)
  312.                 {
  313.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed to find a 'name' attribute in a 'tag' node.");
  314.                         return false;
  315.                 }
  316.  
  317.                 const TagID tagId = tagDefinitionOut.AddTag(tagName, groupName, priority);
  318.                 if (tagId == TAG_ID_INVALID)
  319.                 {
  320.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Duplicate tag '%s'", tagName);
  321.                         // We will continue loading
  322.                 }
  323.                 else
  324.                 {
  325.                         const char* const pSubTagsFilename = pXmlNode->getAttr("subTagDef");
  326.                         if (pSubTagsFilename && pSubTagsFilename[0])
  327.                         {
  328.                                 IAnimationDatabaseManager& animationDatabaseManager = gEnv->pGameFramework->GetMannequinInterface().GetAnimationDatabaseManager();
  329.                                 const CTagDefinition* pTagDef = animationDatabaseManager.LoadTagDefs(pSubTagsFilename, true);
  330.                                 if (pTagDef)
  331.                                 {
  332.                                         tagDefinitionOut.SetSubTagDefinition(tagId, pTagDef);
  333.                                 }
  334.                         }
  335.                 }
  336.  
  337.                 importsInfo.AddTag(tagId);
  338.  
  339.                 return true;
  340.         }
  341.  
  342.         static bool LoadGroupNode(XmlNodeRef pXmlNode, const int childCount, CTagDefinition& tagDefinitionOut, STagDefinitionImportsInfo& importsInfo)
  343.         {
  344.                 assert(pXmlNode != 0);
  345.                 assert(pXmlNode->getChildCount() == childCount);
  346.  
  347.                 const char* const groupName = pXmlNode->getAttr("name");
  348.                 if (!groupName)
  349.                 {
  350.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed to find a 'name' attribute in a 'group' node.");
  351.                         return false;
  352.                 }
  353.                 else if (tagDefinitionOut.FindGroup(groupName) != GROUP_ID_NONE)
  354.                 {
  355.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Group '%s' overrides existing group.", groupName);
  356.                         return false;
  357.                 }
  358.  
  359.                 bool loadSuccess = true;
  360.                 for (int i = 0; i < childCount; ++i)
  361.                 {
  362.                         XmlNodeRef pXmlChildNode = pXmlNode->getChild(i);
  363.                         loadSuccess &= LoadTagNode(pXmlChildNode, groupName, tagDefinitionOut, importsInfo);
  364.                 }
  365.                 return loadSuccess;
  366.         }
  367.  
  368.         static XmlNodeRef CreateChildNode(XmlNodeRef pXmlNode, const char* const childName)
  369.         {
  370.                 assert(pXmlNode != 0);
  371.                 assert(childName);
  372.                 assert(childName[0]);
  373.  
  374.                 XmlNodeRef pXmlChildNode = pXmlNode->createNode(childName);
  375.                 pXmlNode->addChild(pXmlChildNode);
  376.                 return pXmlChildNode;
  377.         }
  378.  
  379.         static void SaveImportsNode(XmlNodeRef pXmlNode, const TImportsList& importsList)
  380.         {
  381.                 assert(pXmlNode != 0);
  382.  
  383.                 const size_t importsCount = importsList.size();
  384.                 if (importsCount == 0)
  385.                 {
  386.                         return;
  387.                 }
  388.  
  389.                 XmlNodeRef pXmlImportsNode = CreateChildNode(pXmlNode, "Imports");
  390.  
  391.                 for (size_t i = 0; i < importsCount; ++i)
  392.                 {
  393.                         const string& filename = importsList[i];
  394.                         SaveImportNode(pXmlImportsNode, filename);
  395.                 }
  396.         }
  397.  
  398.         static void SaveImportNode(XmlNodeRef pXmlNode, const string& filename)
  399.         {
  400.                 assert(pXmlNode != 0);
  401.  
  402.                 XmlNodeRef pXmlImportNode = CreateChildNode(pXmlNode, "Import");
  403.                 pXmlImportNode->setAttr("filename", filename.c_str());
  404.         }
  405.  
  406.         static void SaveTagsNode(XmlNodeRef pXmlNode, const CTagDefinition& tagDefinition)
  407.         {
  408.                 const TagID tagCount = tagDefinition.GetNum();
  409.                 if (tagCount == 0)
  410.                 {
  411.                         return;
  412.                 }
  413.  
  414.                 XmlNodeRef pXmlTagsNode = CreateChildNode(pXmlNode, "Tags");
  415.  
  416.                 std::vector<XmlNodeRef> groupXmlNodes;
  417.  
  418.                 const TagGroupID groupCount = tagDefinition.GetNumGroups();
  419.                 groupXmlNodes.resize(groupCount);
  420.                 for (TagGroupID i = 0; i < groupCount; ++i)
  421.                 {
  422.                         const char* const groupName = tagDefinition.GetGroupName(i);
  423.                         XmlNodeRef pXmlTagGroup = CreateChildNode(pXmlTagsNode, "Group");
  424.                         pXmlTagGroup->setAttr("name", groupName);
  425.  
  426.                         groupXmlNodes[i] = pXmlTagGroup;
  427.                 }
  428.  
  429.                 for (TagID i = 0; i < tagCount; ++i)
  430.                 {
  431.                         const char* const tagName = tagDefinition.GetTagName(i);
  432.                         XmlNodeRef pXmlTagNode = pXmlTagsNode->createNode("Tag");
  433.                         pXmlTagNode->setAttr("name", tagName);
  434.  
  435.                         const uint32 tagPriority = tagDefinition.GetPriority(i);
  436.                         if (tagPriority != 0)
  437.                         {
  438.                                 pXmlTagNode->setAttr("priority", tagPriority);
  439.                         }
  440.  
  441.                         const CTagDefinition* pTagDef = tagDefinition.GetSubTagDefinition(i);
  442.                         if (pTagDef)
  443.                         {
  444.                                 pXmlTagNode->setAttr("subTagDef", pTagDef->GetFilename());
  445.                         }
  446.  
  447.                         const TagGroupID groupId = tagDefinition.GetGroupID(i);
  448.                         if (groupId == GROUP_ID_NONE)
  449.                         {
  450.                                 pXmlTagsNode->addChild(pXmlTagNode);
  451.                         }
  452.                         else
  453.                         {
  454.                                 XmlNodeRef pXmlTagGroup = groupXmlNodes[groupId];
  455.                                 pXmlTagGroup->addChild(pXmlTagNode);
  456.                         }
  457.                 }
  458.         }
  459. };
  460.  
  461. //////////////////////////////////////////////////////////////////////////
  462. int mannequin::GetTagDefinitionVersion(XmlNodeRef pXmlNode)
  463. {
  464.         if (stricmp(pXmlNode->getTag(), "TagDefinition") != 0)
  465.         {
  466.                 return -1;
  467.         }
  468.  
  469.         int version = 1;
  470.         pXmlNode->getAttr("version", version);
  471.         return version;
  472. }
  473.  
  474. //////////////////////////////////////////////////////////////////////////
  475. bool mannequin::LoadTagDefinitionImpl(const char* const filename, CTagDefinition& tagDefinitionOut,
  476. #if RECURSIVE_IMPORT_CHECK
  477.                                       TRecursiveGuardList& recursiveGuardListOut,
  478. #endif
  479.                                       STagDefinitionImportsInfo& importsInfo)
  480. {
  481.         assert(filename);
  482.         assert(filename[0]);
  483.  
  484. #if RECURSIVE_IMPORT_CHECK
  485.         for (int i = 0; i < recursiveGuardListOut.size(); ++i)
  486.         {
  487.                 const char* const alreadyLoadedFilename = recursiveGuardListOut[i];
  488.                 if (stricmp(filename, alreadyLoadedFilename) == 0)
  489.                 {
  490.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed to load tag definition file '%s' due to a cyclic dependency.", filename);
  491.                         return false;
  492.                 }
  493.         }
  494.  
  495.         recursiveGuardListOut.push_back(filename);
  496. #endif
  497.  
  498.         XmlNodeRef pXmlNode = gEnv->pSystem->LoadXmlFromFile(filename);
  499.         if (!pXmlNode)
  500.         {
  501.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed to load tag definition file '%s'", filename);
  502.                 return false;
  503.         }
  504.  
  505.         CRY_DEFINE_ASSET_SCOPE("TagDefinition", filename);
  506.         const bool loadSuccess = impl::LoadTagDefinitionImplXml(pXmlNode, tagDefinitionOut,
  507. #if RECURSIVE_IMPORT_CHECK
  508.                                                                 recursiveGuardListOut,
  509. #endif
  510.                                                                 importsInfo);
  511.         return loadSuccess;
  512. }
  513.  
  514. //////////////////////////////////////////////////////////////////////////
  515. bool mannequin::impl::LoadTagDefinitionImplXml(XmlNodeRef pXmlNode, CTagDefinition& tagDefinitionOut,
  516. #if RECURSIVE_IMPORT_CHECK
  517.                                                TRecursiveGuardList& recursiveGuardListOut,
  518. #endif
  519.                                                STagDefinitionImportsInfo& importsInfo)
  520. {
  521.         assert(pXmlNode != 0);
  522.  
  523.         bool loadSuccess = false;
  524.  
  525.         const int version = GetTagDefinitionVersion(pXmlNode);
  526.         switch (version)
  527.         {
  528.         case 2:
  529.                 loadSuccess = STagDefinitionXml<2>::Load(pXmlNode, tagDefinitionOut,
  530. #if RECURSIVE_IMPORT_CHECK
  531.                                                          recursiveGuardListOut,
  532. #endif
  533.                                                          importsInfo);
  534.                 break;
  535.         case 1:
  536.                 loadSuccess = STagDefinitionXml<1>::Load(pXmlNode, tagDefinitionOut,
  537. #if RECURSIVE_IMPORT_CHECK
  538.                                                          recursiveGuardListOut,
  539. #endif
  540.                                                          importsInfo);
  541.                 break;
  542.         default:
  543.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed to load tag definition: Unsupported version '%d'", version);
  544.                 break;
  545.         }
  546.  
  547.         return loadSuccess;
  548. }
  549.  
  550. //////////////////////////////////////////////////////////////////////////
  551. bool mannequin::LoadTagDefinition(const char* const filename, CTagDefinition& tagDefinitionOut, bool isTags)
  552. {
  553.         assert(filename);
  554.         assert(filename[0]);
  555.  
  556.         tagDefinitionOut.Clear();
  557.         tagDefinitionOut.SetFilename(filename);
  558.  
  559. #if RECURSIVE_IMPORT_CHECK
  560.         TRecursiveGuardList recursiveGuardListOut;
  561. #endif
  562.  
  563.         STagDefinitionImportsInfo& importsInfo = GetDefaultImportsInfo(filename);
  564.         importsInfo.Clear();
  565.         const bool loadSuccess = LoadTagDefinitionImpl(filename, tagDefinitionOut,
  566. #if RECURSIVE_IMPORT_CHECK
  567.                                                        recursiveGuardListOut,
  568. #endif
  569.                                                        importsInfo);
  570.  
  571.         if (isTags)
  572.         {
  573.                 tagDefinitionOut.AssignBits();
  574.         }
  575.  
  576.         return loadSuccess;
  577. }
  578.  
  579. //////////////////////////////////////////////////////////////////////////
  580. XmlNodeRef mannequin::SaveTagDefinitionImpl(const CTagDefinition& tagDefinition, const TImportsList& importList)
  581. {
  582.         XmlNodeRef pXmlNode = GetISystem()->CreateXmlNode("TagDefinition");
  583.         STagDefinitionXml<2>::Save(pXmlNode, tagDefinition, importList);
  584.         return pXmlNode;
  585. }
  586.  
  587. //////////////////////////////////////////////////////////////////////////
  588. XmlNodeRef mannequin::SaveTagDefinition(const CTagDefinition& tagDefinition)
  589. {
  590.         const TImportsList emptyImportList;
  591.         return SaveTagDefinitionImpl(tagDefinition, emptyImportList);
  592. }
  593.  
  594. //////////////////////////////////////////////////////////////////////////
  595. namespace
  596. {
  597. size_t FindImportInfoIndex(const std::vector<const STagDefinitionImportsInfo*>& importsInfoList, const STagDefinitionImportsInfo& importsInfo)
  598. {
  599.         const size_t totalImportsInfoCount = importsInfoList.size();
  600.         for (size_t i = 0; i < totalImportsInfoCount; ++i)
  601.         {
  602.                 const STagDefinitionImportsInfo* pCurrentImportsInfo = importsInfoList[i];
  603.                 if (pCurrentImportsInfo == &importsInfo)
  604.                 {
  605.                         return i;
  606.                 }
  607.         }
  608.         assert(false);
  609.         return size_t(~0);
  610. }
  611. }
  612.  
  613. //////////////////////////////////////////////////////////////////////////
  614. void mannequin::SaveTagDefinition(const CTagDefinition& tagDefinition, TTagDefinitionSaveDataList& saveDataListOut)
  615. {
  616.         const char* const mainFilename = tagDefinition.GetFilename();
  617.         const STagDefinitionImportsInfo& importsInfo = GetDefaultImportsInfo(mainFilename);
  618.  
  619.         std::vector<const STagDefinitionImportsInfo*> importsInfoList;
  620.         importsInfo.FlattenImportsInfo(importsInfoList);
  621.         const size_t totalImportsInfoCount = importsInfoList.size();
  622.  
  623.         std::vector<CTagDefinition> saveTagDefinitionList;
  624.         saveTagDefinitionList.resize(totalImportsInfoCount);
  625.  
  626.         for (size_t i = 0; i < totalImportsInfoCount; ++i)
  627.         {
  628.                 const STagDefinitionImportsInfo* pImportsInfo = importsInfoList[i];
  629.                 assert(pImportsInfo);
  630.                 const char* const filename = pImportsInfo->GetFilename();
  631.  
  632.                 CTagDefinition& tagDefinitionSave = saveTagDefinitionList[i];
  633.                 tagDefinitionSave.SetFilename(filename);
  634.         }
  635.  
  636.         const TagID tagCount = tagDefinition.GetNum();
  637.         for (TagID tagId = 0; tagId < tagCount; ++tagId)
  638.         {
  639.                 const STagDefinitionImportsInfo& importInfoForTag = importsInfo.Find(tagId);
  640.  
  641.                 const size_t importInfoId = FindImportInfoIndex(importsInfoList, importInfoForTag);
  642.                 assert(importInfoId < importsInfoList.size());
  643.  
  644.                 const char* const tagName = tagDefinition.GetTagName(tagId);
  645.                 const TagGroupID tagGroupId = tagDefinition.GetGroupID(tagId);
  646.                 const char* const groupName = (tagGroupId == GROUP_ID_NONE) ? NULL : tagDefinition.GetGroupName(tagGroupId);
  647.                 const int tagPriority = tagDefinition.GetPriority(tagId);
  648.  
  649.                 CTagDefinition& tagDefinitionSave = saveTagDefinitionList[importInfoId];
  650.                 TagID newTagID = tagDefinitionSave.AddTag(tagName, groupName, tagPriority);
  651.                 tagDefinitionSave.SetSubTagDefinition(newTagID, tagDefinition.GetSubTagDefinition(tagId));
  652.         }
  653.  
  654.         for (size_t i = 0; i < totalImportsInfoCount; ++i)
  655.         {
  656.                 const STagDefinitionImportsInfo* pImportsInfo = importsInfoList[i];
  657.                 const CTagDefinition& tagDefinitionSave = saveTagDefinitionList[i];
  658.  
  659.                 TImportsList importList;
  660.                 const size_t subImportsCount = pImportsInfo->GetImportCount();
  661.                 for (size_t j = 0; j < subImportsCount; ++j)
  662.                 {
  663.                         const STagDefinitionImportsInfo& subImportInfo = pImportsInfo->GetImport(j);
  664.                         const char* const filename = subImportInfo.GetFilename();
  665.                         // prevent duplicate import entries
  666.                         if (std::find(importList.begin(), importList.end(), filename) == importList.end())
  667.                         {
  668.                                 importList.push_back(filename);
  669.                         }
  670.                 }
  671.  
  672.                 STagDefinitionSaveData saveInfo;
  673.                 saveInfo.pXmlNode = SaveTagDefinitionImpl(tagDefinitionSave, importList);
  674.                 saveInfo.filename = tagDefinitionSave.GetFilename();
  675.  
  676.                 saveDataListOut.push_back(saveInfo);
  677.         }
  678. }
  679.  
downloadTagDefinitionXml.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