BVB Source Codes

CRYENGINE Show AnimationManager.cpp Source code

Return Download CRYENGINE: download AnimationManager.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 "AnimationManager.h"
  5.  
  6. #include "LoaderTCB.h"
  7. #include "ModelAnimationSet.h"
  8. #include "LoaderCGA.h"
  9. #include "LoaderDBA.h"
  10. #include <CryCore/StlUtils.h>
  11. #include "ControllerPQ.h"
  12. #include "ControllerOpt.h"
  13. #include "ParametricSampler.h"
  14. #include "CharacterManager.h"
  15. #include "Model.h"
  16. #include <CryString/StringUtils.h>
  17. #include <CryString/CryPath.h>
  18.  
  19. int CAnimationManager::GetGlobalIDbyFilePath_CAF(const char* szAnimFileName) const
  20. {
  21.         const int id = m_AnimationMapCAF.GetValue(szAnimFileName);
  22.         if (id >= 0)
  23.         {
  24.                 assert(size_t(id) < m_arrGlobalCAF.size());
  25.                 assert(!stricmp(m_arrGlobalCAF[id].GetFilePath(), szAnimFileName));
  26.                 return id;
  27.         }
  28.         return -1;
  29. }
  30.  
  31. int CAnimationManager::GetGlobalIDbyFilePath_AIM(const char* szAnimFilePath) const
  32. {
  33.         const uint32 crc32 = CCrc32::ComputeLowercase(szAnimFilePath);
  34.  
  35.         const uint32 numAIM = m_arrGlobalAIM.size();
  36.         for (uint32 id = 0; id < numAIM; ++id)
  37.         {
  38.                 if (m_arrGlobalAIM[id].GetFilePathCRC32() == crc32)
  39.                 {
  40.                         assert(!stricmp(m_arrGlobalAIM[id].GetFilePath(), szAnimFilePath));
  41.                         return id;
  42.                 }
  43.         }
  44.  
  45.         return -1;
  46. }
  47.  
  48. int CAnimationManager::GetGlobalIDbyFilePath_LMG(const char* szAnimFilePath) const
  49. {
  50.         const int id = GetGlobalIDbyFilePathCRC_LMG(CCrc32::ComputeLowercase(szAnimFilePath));
  51.         assert(id == -1 || stricmp(m_arrGlobalLMG[id].GetFilePath(), szAnimFilePath) == 0);
  52.  
  53.         return id;
  54. }
  55.  
  56. int CAnimationManager::GetGlobalIDbyFilePathCRC_LMG(uint32 crc32) const
  57. {
  58.         const uint32 numLMG = m_arrGlobalLMG.size();
  59.         for (uint32 id = 0; id < numLMG; ++id)
  60.         {
  61.                 if (m_arrGlobalLMG[id].GetFilePathCRC32() == crc32)
  62.                 {
  63.                         return id;
  64.                 }
  65.         }
  66.  
  67.         return -1;
  68. }
  69.  
  70. ////////////////////////////////////////////////////////////////////////////////////
  71. // loads the animation with the specified name; if the animation is already loaded,
  72. // then just returns its id
  73. // The caller MUST TAKE CARE to bind the animation if it's already loaded before it has registered itself within this manager
  74. // RETURNS:
  75. //   The global animation id.
  76. //   -1 if the animation couldn't be loaded
  77. // SIDE EFFECT NOTES:
  78. //   This function does not put up a warning in the case the file was not found.
  79. //   The caller must do so.
  80. int CAnimationManager::CreateGAH_CAF(const string& strFilePath)
  81. {
  82.         int nGlobalAnimId = GetGlobalIDbyFilePath_CAF(strFilePath);
  83.         if (nGlobalAnimId < 0)
  84.         {
  85.                 nGlobalAnimId = int32(m_arrGlobalCAF.size());
  86.                 // add a new animation structure that will hold the info about the new animation.
  87.                 // the new animation id is the index of this structure in the array
  88.  
  89.                 m_arrGlobalCAF.push_back();
  90.                 m_arrGlobalCAF[nGlobalAnimId] = GlobalAnimationHeaderCAF();
  91.  
  92.                 m_arrGlobalCAF[nGlobalAnimId].SetFilePath(strFilePath);
  93.                 m_animSearchHelper.AddAnimation(strFilePath, nGlobalAnimId);
  94.                 m_AnimationMapCAF.InsertValue(m_arrGlobalCAF[nGlobalAnimId].GetFilePathCRC32(), nGlobalAnimId);
  95.         }
  96.         return nGlobalAnimId;
  97. }
  98.  
  99. int CAnimationManager::CreateGAH_AIM(const string& strFilePath)
  100. {
  101.         int nGlobalAnimId = GetGlobalIDbyFilePath_AIM(strFilePath);
  102.         if (nGlobalAnimId < 0)
  103.         {
  104.                 nGlobalAnimId = int32(m_arrGlobalAIM.size());
  105.                 // add a new animation structure that will hold the info about the new animation.
  106.                 // the new animation id is the index of this structure in the array
  107.                 m_arrGlobalAIM.push_back(GlobalAnimationHeaderAIM());
  108.                 m_arrGlobalAIM[nGlobalAnimId].SetFilePath(strFilePath);
  109.                 //      m_AnimationMapAIM.InsertValue(m_arrGlobalAIM[nGlobalAnimId].GetFilePathCRC32(), nGlobalAnimId);
  110.         }
  111.         return nGlobalAnimId;
  112. }
  113.  
  114. int CAnimationManager::CreateGAH_LMG(const string& strFilePath)
  115. {
  116.         int nGlobalAnimId = GetGlobalIDbyFilePath_LMG(strFilePath);
  117.         if (nGlobalAnimId < 0)
  118.         {
  119.                 nGlobalAnimId = int32(m_arrGlobalLMG.size());
  120.                 // add a new animation structure that will hold the info about the new animation.
  121.                 // the new animation id is the index of this structure in the array
  122.                 m_arrGlobalLMG.push_back(GlobalAnimationHeaderLMG());
  123.                 m_arrGlobalLMG[nGlobalAnimId].SetFilePath(strFilePath);
  124.                 //      m_AnimationMapLMG.InsertValue(m_arrGlobalLMG[nGlobalAnimId].GetFilePathCRC32(), nGlobalAnimId);
  125.         }
  126.         return nGlobalAnimId;
  127. }
  128.  
  129. CGlobalHeaderDBA* CAnimationManager::FindGlobalHeaderByCRC_DBA(uint32 crc)
  130. {
  131.         for (size_t i = 0, c = m_arrGlobalHeaderDBA.size(); i != c; ++i)
  132.         {
  133.                 if (m_arrGlobalHeaderDBA[i].m_FilePathDBACRC32 == crc)
  134.                         return &m_arrGlobalHeaderDBA[i];
  135.         }
  136.  
  137.         return NULL;
  138. }
  139.  
  140. bool CAnimationManager::LoadAnimationTCB(int nAnimId, DynArray<CControllerTCB>& arrNodeAnims, CryCGALoader* pCGA, const IDefaultSkeleton* pIDefaultSkeleton)
  141. {
  142.         if (pIDefaultSkeleton == 0)
  143.                 return 0;
  144.         const CDefaultSkeleton* pDefaultSkeleton = (const CDefaultSkeleton*)pIDefaultSkeleton;
  145.  
  146.         LOADING_TIME_PROFILE_SECTION(g_pISystem);
  147.  
  148.         GlobalAnimationHeaderCAF& rGlobalAnim = m_arrGlobalCAF[nAnimId];
  149.         int32 nStartKey = pCGA->m_start;
  150.         int32 nEndKey = pCGA->m_end;
  151.  
  152.         rGlobalAnim.m_fStartSec = nStartKey / ANIMATION_30Hz;
  153.         rGlobalAnim.m_fEndSec = nEndKey / ANIMATION_30Hz;
  154.         if (rGlobalAnim.m_fEndSec <= rGlobalAnim.m_fStartSec)
  155.                 rGlobalAnim.m_fEndSec = rGlobalAnim.m_fStartSec;
  156.  
  157.         rGlobalAnim.m_fTotalDuration = rGlobalAnim.m_fEndSec - rGlobalAnim.m_fStartSec;
  158.  
  159.         uint32 numCtrl = rGlobalAnim.m_nControllers;
  160.         assert(numCtrl == 0);
  161.         if (numCtrl)
  162.                 return true;
  163.  
  164.         uint32 numController = 0;
  165.         uint32 numAnimSize = arrNodeAnims.size();
  166.         for (uint32 i = 0; i < numAnimSize; i++)
  167.         {
  168.                 uint32 numPos = arrNodeAnims[i].m_posTrack.num_keys();
  169.                 uint32 numRot = arrNodeAnims[i].m_rotTrack.num_keys();
  170.                 uint32 numScl = arrNodeAnims[i].m_sclTrack.num_keys();
  171.                 if (numPos + numRot + numScl)
  172.                         numController++;
  173.         }
  174.         rGlobalAnim.m_arrController.resize(numController);
  175.         rGlobalAnim.m_nControllers = numController;
  176.         rGlobalAnim.m_nControllers2 = numController;
  177.  
  178.         for (uint32 i = 0, j = 0; i < numAnimSize; i++)
  179.         {
  180.                 uint32 numPos = arrNodeAnims[i].m_posTrack.num_keys();
  181.                 uint32 numRot = arrNodeAnims[i].m_rotTrack.num_keys();
  182.                 uint32 numScl = arrNodeAnims[i].m_sclTrack.num_keys();
  183.                 if (numPos + numRot + numScl)
  184.                 {
  185.                         CControllerTCB* pControllerTCB = new CControllerTCB();
  186.                         *pControllerTCB = arrNodeAnims[i];
  187.  
  188.                         pControllerTCB->m_nControllerId = pDefaultSkeleton->m_arrModelJoints[i].m_nJointCRC32;
  189.  
  190.                         IController* pController = (IController*)pControllerTCB;
  191.                         PREFAST_SUPPRESS_WARNING(6386)
  192.                         rGlobalAnim.m_arrController[j] = static_cast<IController*>(pController);
  193.                         ++j;
  194.                 }
  195.         }
  196.  
  197.         std::sort(rGlobalAnim.m_arrController.begin(), rGlobalAnim.m_arrController.end(), AnimCtrlSortPred());
  198.  
  199.         rGlobalAnim.InitControllerLookup(numController);
  200.         rGlobalAnim.OnAssetCreated();
  201.         rGlobalAnim.m_nFlags |= CA_ASSET_TCB;
  202.         return true;
  203. }
  204.  
  205. // notifies the controller manager that this client doesn't use the given animation any more.
  206. // these calls must be balanced with AnimationAddRef() calls
  207. void CAnimationManager::AnimationReleaseCAF(GlobalAnimationHeaderCAF& rCAF)
  208. {
  209.         int32 RefCount = rCAF.m_nRef_by_Model;
  210.         if (RefCount == 0)
  211.                 rCAF.Release();
  212. }
  213. void CAnimationManager::AnimationReleaseAIM(GlobalAnimationHeaderAIM& rAIM)
  214. {
  215.         int32 RefCount = rAIM.m_nRef_by_Model;
  216.         if (RefCount == 0)
  217.                 rAIM.Release();
  218. }
  219. void CAnimationManager::AnimationReleaseLMG(GlobalAnimationHeaderLMG& rLMG)
  220. {
  221.         int32 RefCount = rLMG.m_nRef_by_Model;
  222.         if (RefCount == 0)
  223.                 rLMG.Release();
  224. }
  225.  
  226. //////////////////////////////////////////////////////////////////////////
  227. IAnimEventList* CAnimationManager::GetAnimEventList(const char* animationFilePath)
  228. {
  229.         const CAnimationManager* cThis = this;
  230.         const IAnimEventList* pAnimEventArray = cThis->GetAnimEventList(animationFilePath);
  231.         return const_cast<IAnimEventList*>(pAnimEventArray);
  232. }
  233.  
  234. const IAnimEventList* CAnimationManager::GetAnimEventList(const char* animationFilePath) const
  235. {
  236.         const int32 globalCafId = GetGlobalIDbyFilePath_CAF(animationFilePath);
  237.         if (0 <= globalCafId)
  238.         {
  239.                 assert(globalCafId < (int32)(m_arrGlobalCAF.size()));
  240.                 return &m_arrGlobalCAF[globalCafId].m_AnimEventsCAF;
  241.         }
  242.  
  243.         const int32 globalLmgId = GetGlobalIDbyFilePath_LMG(animationFilePath);
  244.         if (0 <= globalLmgId)
  245.         {
  246.                 assert(globalLmgId < (int32)(m_arrGlobalLMG.size()));
  247.                 return &m_arrGlobalLMG[globalLmgId].m_AnimEventsLMG;
  248.         }
  249.  
  250.         return NULL;
  251. }
  252.  
  253. bool CAnimationManager::SaveAnimEventToXml(const CAnimEventData& dataIn, XmlNodeRef& dataOut)
  254. {
  255.         if (!dataOut)
  256.                 return false;
  257.  
  258.         dataOut->setTag("event");
  259.         dataOut->setAttr("name", dataIn.GetName());
  260.         dataOut->setAttr("time", dataIn.GetNormalizedTime());
  261.         dataOut->setAttr("endTime", dataIn.GetNormalizedEndTime());
  262.         dataOut->setAttr("parameter", dataIn.GetCustomParameter());
  263.         dataOut->setAttr("bone", dataIn.GetBoneName());
  264.         dataOut->setAttr("offset", dataIn.GetOffset());
  265.         dataOut->setAttr("dir", dataIn.GetDirection());
  266.         dataOut->setAttr("model", dataIn.GetModelName());
  267.  
  268.         return true;
  269. }
  270.  
  271. bool CAnimationManager::LoadAnimEventFromXml(const XmlNodeRef& dataIn, CAnimEventData& dataOut)
  272. {
  273.         if (!dataIn)
  274.                 return false;
  275.  
  276.         if (stack_string("event") != dataIn->getTag())
  277.                 return false;
  278.  
  279.         XmlString sEventName;
  280.         if (!(sEventName = dataIn->getAttr("name")))
  281.                 sEventName = "__unnamed__";
  282.  
  283.         float fTime = 0.f;
  284.         dataIn->getAttr("time", fTime);
  285.  
  286.         float endTime = fTime;
  287.         dataIn->getAttr("endTime", endTime);
  288.  
  289.         XmlString sParameter;
  290.         sParameter = dataIn->getAttr("parameter");
  291.  
  292.         XmlString sBoneName;
  293.         sBoneName = dataIn->getAttr("bone");
  294.  
  295.         Vec3 vOffset(0, 0, 0);
  296.         dataIn->getAttr("offset", vOffset);
  297.  
  298.         Vec3 vDir(0, 0, 0);
  299.         dataIn->getAttr("dir", vDir);
  300.  
  301.         XmlString sModel;
  302.         sModel = dataIn->getAttr("model");
  303.  
  304.         dataOut.SetName(sEventName);
  305.         dataOut.SetNormalizedTime(fTime);
  306.         dataOut.SetNormalizedEndTime(endTime);
  307.         dataOut.SetCustomParameter(sParameter);
  308.         dataOut.SetBoneName(sBoneName);
  309.         dataOut.SetOffset(vOffset);
  310.         dataOut.SetDirection(vDir);
  311.         dataOut.SetModelName(sModel);
  312.  
  313.         return true;
  314. }
  315.  
  316. void CAnimationManager::InitializeSegmentationDataFromAnimEvents(const char* animationFilePath)
  317. {
  318.         const int32 globalCafId = GetGlobalIDbyFilePath_CAF(animationFilePath);
  319.         if (globalCafId < 0)
  320.                 return;
  321.  
  322.         static const uint32 s_crc32_segment1 = CCrc32::ComputeLowercase("segment1");
  323.         static const uint32 s_crc32_segment2 = CCrc32::ComputeLowercase("segment2");
  324.         static const uint32 s_crc32_segment3 = CCrc32::ComputeLowercase("segment3");
  325.  
  326.         GlobalAnimationHeaderCAF& cafHeader = m_arrGlobalCAF[globalCafId];
  327.         cafHeader.m_Segments = 1;
  328.  
  329.         const IAnimEventList& animEvents = cafHeader.m_AnimEventsCAF;
  330.         const uint32 animEventCount = animEvents.GetCount();
  331.         for (uint32 i = 0; i < animEventCount; ++i)
  332.         {
  333.                 const CAnimEventData& animEvent = animEvents.GetByIndex(i);
  334.                 const uint32 eventNameCRC32 = animEvent.GetNameLowercaseCRC32();
  335.                 float normalizedTime = animEvent.GetNormalizedTime();
  336.  
  337.                 uint32 ind = -1;
  338.                 if (eventNameCRC32 == s_crc32_segment1)
  339.                 {
  340.                         ind = 1;
  341.                 }
  342.                 else if (eventNameCRC32 == s_crc32_segment2)
  343.                 {
  344.                         ind = 2;
  345.                 }
  346.                 else if (eventNameCRC32 == s_crc32_segment3)
  347.                 {
  348.                         ind = 3;
  349.                 }
  350.  
  351.                 if (ind != -1)
  352.                 {
  353.                         cafHeader.m_SegmentsTime[ind] = normalizedTime;
  354.                         ++cafHeader.m_Segments;
  355.                 }
  356.         }
  357. }
  358.  
  359. //---------------------------------------------------------------------------------------------
  360. //---------------------------------------------------------------------------------------------
  361. //---------------------------------------------------------------------------------------------
  362. bool CAnimationManager::CreateGlobalHeaderDBA(DynArray<string>& arrFilePathDBA)
  363. {
  364.         uint32 numDBAs = arrFilePathDBA.size();
  365.         for (size_t d = 0; d < numDBAs; d++)
  366.         {
  367.                 const char* pFilePathDBA = arrFilePathDBA[d];
  368.  
  369.                 uint32 numHeaders = m_arrGlobalHeaderDBA.size();
  370.                 uint32 exits = 0;
  371.                 for (uint32 dba = 0; dba < numHeaders; dba++)
  372.                 {
  373.                         const char* pname = m_arrGlobalHeaderDBA[dba].m_strFilePathDBA;
  374.                         int32 same = stricmp(pname, pFilePathDBA);
  375.                         if (same == 0)
  376.                         {
  377.                                 exits = 1;
  378.                                 break;
  379.                         }
  380.                 }
  381.  
  382.                 if (exits == 0)
  383.                 {
  384.                         //create GloablHeaderDBA and load data
  385.                         CGlobalHeaderDBA HeaderDBA;
  386.                         HeaderDBA.CreateDatabaseDBA(pFilePathDBA);
  387.                         m_arrGlobalHeaderDBA.push_back(HeaderDBA);
  388.                 }
  389.         }
  390.         return 0;
  391. }
  392.  
  393. //---------------------------------------------------------------------------------------------
  394. //---------------------------------------------------------------------------------------------
  395. //---------------------------------------------------------------------------------------------
  396. bool CAnimationManager::DBA_PreLoad(const char* pFilePathDBA, bool highPriority)
  397. {
  398.         stack_string strPath = pFilePathDBA;
  399.         PathUtil::UnifyFilePath(strPath);
  400.  
  401.         uint32 numHeaders = m_arrGlobalHeaderDBA.size();
  402.         for (uint32 dba = 0; dba < numHeaders; dba++)
  403.         {
  404.                 const char* pname = m_arrGlobalHeaderDBA[dba].m_strFilePathDBA;
  405.                 int32 same = stricmp(pname, strPath.c_str());
  406.                 if (same == 0)
  407.                 {
  408.                         if (Console::GetInst().ca_UseIMG_CAF)
  409.                                 m_arrGlobalHeaderDBA[dba].StartStreamingDBA(highPriority);
  410.                         else
  411.                                 m_arrGlobalHeaderDBA[dba].LoadDatabaseDBA("");
  412.                         return 1;
  413.                 }
  414.         }
  415.  
  416.         //create GloablHeaderDBA and load data
  417.         CGlobalHeaderDBA HeaderDBA;
  418.         HeaderDBA.CreateDatabaseDBA(strPath.c_str());
  419.         m_arrGlobalHeaderDBA.push_back(HeaderDBA);
  420.         uint32 lastDBA = m_arrGlobalHeaderDBA.size() - 1;
  421.  
  422.         if (Console::GetInst().ca_UseIMG_CAF)
  423.                 m_arrGlobalHeaderDBA[lastDBA].StartStreamingDBA(highPriority);
  424.         else
  425.                 m_arrGlobalHeaderDBA[lastDBA].LoadDatabaseDBA("");
  426.  
  427.         return 0;
  428. }
  429.  
  430. bool CAnimationManager::DBA_LockStatus(const char* pFilePathDBA, uint32 status, bool highPriority)
  431. {
  432.         stack_string strPath = pFilePathDBA;
  433.         PathUtil::UnifyFilePath(strPath);
  434.  
  435.         uint32 numHeaders = m_arrGlobalHeaderDBA.size();
  436.         for (uint32 dba = 0; dba < numHeaders; dba++)
  437.         {
  438.                 const char* pname = m_arrGlobalHeaderDBA[dba].m_strFilePathDBA;
  439.                 int32 same = stricmp(pname, strPath.c_str());
  440.                 if (same == 0)
  441.                 {
  442.                         m_arrGlobalHeaderDBA[dba].m_bDBALock = status;
  443.                         if (status)
  444.                         {
  445.                                 if (Console::GetInst().ca_UseIMG_CAF)
  446.                                         m_arrGlobalHeaderDBA[dba].StartStreamingDBA(highPriority);
  447.                                 else
  448.                                         m_arrGlobalHeaderDBA[dba].LoadDatabaseDBA("");
  449.                         }
  450.                         return 1;
  451.                 }
  452.         }
  453.         return 0;
  454. }
  455.  
  456. bool CAnimationManager::DBA_Unload(const char* pFilePathDBA)
  457. {
  458.         stack_string strPath = pFilePathDBA;
  459.         PathUtil::UnifyFilePath(strPath);
  460.  
  461.         uint32 numHeadersDBA = m_arrGlobalHeaderDBA.size();
  462.         if (numHeadersDBA == 0)
  463.                 return 1;
  464.  
  465.         CGlobalHeaderDBA* parrGlobalDBA = &m_arrGlobalHeaderDBA[0];
  466.         for (uint32 d = 0; d < numHeadersDBA; d++)
  467.                 parrGlobalDBA[d].m_nUsedAnimations = 0;
  468.  
  469.         uint32 numHeadersCAF = m_arrGlobalCAF.size();
  470.         if (numHeadersCAF)
  471.         {
  472.                 GlobalAnimationHeaderCAF* parrGlobalCAF = &m_arrGlobalCAF[0];
  473.                 for (uint32 i = 0; i < numHeadersCAF; i++)
  474.                 {
  475.                         if (parrGlobalCAF[i].m_nRef_at_Runtime == 0)
  476.                                 continue;
  477.                         uint32 nCRC32 = parrGlobalCAF[i].m_FilePathDBACRC32;
  478.                         if (nCRC32)
  479.                         {
  480.                                 for (uint32 d = 0; d < numHeadersDBA; d++)
  481.                                 {
  482.                                         if (nCRC32 == parrGlobalDBA[d].m_FilePathDBACRC32)
  483.                                         {
  484.                                                 parrGlobalDBA[d].m_nUsedAnimations++;
  485.                                                 parrGlobalDBA[d].m_nLastUsedTimeDelta = 0;
  486.                                         }
  487.                                 }
  488.                         }
  489.                 }
  490.         }
  491.  
  492.         for (uint32 dba = 0; dba < numHeadersDBA; dba++)
  493.         {
  494.                 const char* pname = m_arrGlobalHeaderDBA[dba].m_strFilePathDBA;
  495.                 int32 same = stricmp(pname, strPath.c_str());
  496.                 if (same == 0)
  497.                 {
  498.                         m_arrGlobalHeaderDBA[dba].m_bDBALock = 0;
  499.  
  500.                         if (m_arrGlobalHeaderDBA[dba].m_pDatabaseInfo == 0)
  501.                                 return 1;
  502.                         if (m_arrGlobalHeaderDBA[dba].m_nUsedAnimations)
  503.                         {
  504.                                 //CryFatalError("CryAnimation: Animations still in use. Can't delete DBA: %s",m_arrGlobalHeaderDBA[dba].m_strFilePathDBA.c_str() );
  505.                                 continue;
  506.                         }
  507.                         m_arrGlobalHeaderDBA[dba].DeleteDatabaseDBA();
  508.                         return 1;
  509.                 }
  510.         }
  511.  
  512.         return 0;
  513. }
  514.  
  515. void CAnimationManager::InitialiseRunTimePools()
  516. {
  517.         const int numParametrics = Console::GetInst().ca_ParametricPoolSize;
  518.  
  519.         if (numParametrics != g_totalParametrics)
  520.         {
  521.                 delete[] g_parametricPool;
  522.                 delete[] g_usedParametrics;
  523.                 g_parametricPool = new SParametricSamplerInternal[numParametrics];
  524.                 g_usedParametrics = new bool[numParametrics];
  525.                 g_totalParametrics = numParametrics;
  526.         }
  527.         memset(g_usedParametrics, 0, numParametrics);
  528. }
  529.  
  530. void CAnimationManager::DestroyRunTimePools()
  531. {
  532.         delete[] g_parametricPool;
  533.         delete[] g_usedParametrics;
  534.         g_parametricPool = NULL;
  535.         g_usedParametrics = NULL;
  536.         g_totalParametrics = 0;
  537. }
  538.  
  539. bool CAnimationManager::Unload_All_Animation()
  540. {
  541.         uint32 numHeadersCAF = m_arrGlobalCAF.size();
  542.         if (numHeadersCAF)
  543.         {
  544.                 //remove all CAFs
  545.                 GlobalAnimationHeaderCAF* parrGlobalCAF = &m_arrGlobalCAF[0];
  546.                 for (uint32 i = 0; i < numHeadersCAF; i++)
  547.                 {
  548.                         parrGlobalCAF[i].m_nRef_at_Runtime = 0;
  549.                         uint32 nCRC32 = parrGlobalCAF[i].m_FilePathDBACRC32;
  550.                         if (nCRC32 == 0 || nCRC32 == -1)
  551.                                 parrGlobalCAF[i].ClearControllers();
  552.                 }
  553.         }
  554.  
  555.         uint32 numHeadersDBA = m_arrGlobalHeaderDBA.size();
  556.         for (uint32 dba = 0; dba < numHeadersDBA; dba++)
  557.         {
  558.                 m_arrGlobalHeaderDBA[dba].m_nUsedAnimations = 0;
  559.                 if (m_arrGlobalHeaderDBA[dba].m_pDatabaseInfo == 0)
  560.                         continue;
  561.                 m_arrGlobalHeaderDBA[dba].DeleteDatabaseDBA();
  562.         }
  563.  
  564.         InitialiseRunTimePools();
  565.  
  566.         return 1;
  567. }
  568.  
  569. bool CAnimationManager::DBA_Unload_All()
  570. {
  571.         uint32 numHeadersDBA = m_arrGlobalHeaderDBA.size();
  572.         if (numHeadersDBA == 0)
  573.                 return 1;
  574.  
  575.         CGlobalHeaderDBA* parrGlobalDBA = &m_arrGlobalHeaderDBA[0];
  576.         for (uint32 d = 0; d < numHeadersDBA; d++)
  577.                 parrGlobalDBA[d].m_nUsedAnimations = 0;
  578.  
  579.         for (uint32 d = 0; d < numHeadersDBA; d++)  //unlock all
  580.                 parrGlobalDBA[d].m_bDBALock = 0;
  581.  
  582.         uint32 numHeadersCAF = m_arrGlobalCAF.size();
  583.         if (numHeadersCAF)
  584.         {
  585.                 GlobalAnimationHeaderCAF* parrGlobalCAF = &m_arrGlobalCAF[0];
  586.                 for (uint32 i = 0; i < numHeadersCAF; i++)
  587.                 {
  588.                         //      parrGlobalCAF[i].m_nRef_at_Runtime=0;
  589.  
  590.                         uint32 nCRC32 = parrGlobalCAF[i].m_FilePathDBACRC32;
  591.                         if (nCRC32 == 0 || nCRC32 == -1)
  592.                                 parrGlobalCAF[i].ClearControllers();
  593.  
  594.                         if (parrGlobalCAF[i].m_nRef_at_Runtime == 0)
  595.                                 continue;
  596.                         if (nCRC32)
  597.                         {
  598.                                 for (uint32 d = 0; d < numHeadersDBA; d++)
  599.                                 {
  600.                                         if (nCRC32 == parrGlobalDBA[d].m_FilePathDBACRC32)
  601.                                         {
  602.                                                 parrGlobalDBA[d].m_nUsedAnimations++;
  603.                                                 parrGlobalDBA[d].m_nLastUsedTimeDelta = 0;
  604.                                         }
  605.                                 }
  606.                         }
  607.                 }
  608.         }
  609.  
  610.         for (uint32 dba = 0; dba < numHeadersDBA; dba++)
  611.         {
  612.                 if (m_arrGlobalHeaderDBA[dba].m_pDatabaseInfo == 0)
  613.                         continue;
  614.                 if (m_arrGlobalHeaderDBA[dba].m_nUsedAnimations)
  615.                 {
  616.                         //CryFatalError("CryAnimation: Animations still in use. Can't delete DBA : %s  used: %d",m_arrGlobalHeaderDBA[dba].m_strFilePathDBA.c_str(), m_arrGlobalHeaderDBA[dba].m_nUsedAnimations );
  617.                         continue;
  618.                 }
  619.                 m_arrGlobalHeaderDBA[dba].DeleteDatabaseDBA();
  620.         }
  621.  
  622.         return 1;
  623. }
  624.  
  625. EReloadCAFResult CAnimationManager::ReloadCAF(const char* szFilePathCAF)
  626. {
  627.         uint32 nCRC32 = CCrc32::ComputeLowercase(szFilePathCAF);
  628.  
  629.         uint32 numAIM = m_arrGlobalAIM.size();
  630.         for (uint32 id = 0; id < numAIM; id++)
  631.         {
  632.                 GlobalAnimationHeaderAIM& rAIM = m_arrGlobalAIM[id];
  633.                 if (rAIM.m_FilePathCRC32 == nCRC32)
  634.                 {
  635.                         assert(!strcmp(rAIM.GetFilePath(), szFilePathCAF));
  636.                         rAIM.m_nControllers = 0;
  637.                         int status = rAIM.LoadAIM();
  638.                         if (status)
  639.                         {
  640.                                 CryLog("Hot loaded animation CAF-file for an Directional-Pose: %s", rAIM.m_FilePath.c_str());
  641.  
  642.                                 CDefaultSkeleton* pDefaultSkeleton = g_pCharacterManager->GetModelByAimPoseID(id);
  643.                                 if (pDefaultSkeleton)
  644.                                 {
  645.                                         uint32 numDB = pDefaultSkeleton->m_poseBlenderAimDesc.m_blends.size();
  646.                                         for (uint32 d = 0; d < numDB; d++)
  647.                                         {
  648.                                                 const char* strAnimToken = pDefaultSkeleton->m_poseBlenderAimDesc.m_blends[d].m_AnimToken;
  649.                                                 uint32 IsAIM = (CryStringUtils::stristr(rAIM.m_FilePath.c_str(), strAnimToken) != 0);
  650.                                                 if (IsAIM)
  651.                                                 {
  652.                                                         rAIM.ProcessDirectionalPoses(pDefaultSkeleton, pDefaultSkeleton->m_poseBlenderAimDesc.m_blends, pDefaultSkeleton->m_poseBlenderAimDesc.m_rotations, pDefaultSkeleton->m_poseBlenderAimDesc.m_positions);
  653.                                                         CryLog("Re-Processed Aim-Pose: %s", rAIM.m_FilePath.c_str());
  654.                                                         break;
  655.                                                 }
  656.                                         }
  657.  
  658.                                         uint32 numLB = pDefaultSkeleton->m_poseBlenderLookDesc.m_blends.size();
  659.                                         for (uint32 d = 0; d < numLB; d++)
  660.                                         {
  661.                                                 const char* strAnimToken = pDefaultSkeleton->m_poseBlenderLookDesc.m_blends[d].m_AnimToken;
  662.                                                 uint32 IsLOOK = (CryStringUtils::stristr(rAIM.m_FilePath.c_str(), strAnimToken) != 0);
  663.                                                 if (IsLOOK)
  664.                                                 {
  665.                                                         rAIM.ProcessDirectionalPoses(pDefaultSkeleton, pDefaultSkeleton->m_poseBlenderLookDesc.m_blends, pDefaultSkeleton->m_poseBlenderLookDesc.m_rotations, pDefaultSkeleton->m_poseBlenderLookDesc.m_positions);
  666.                                                         CryLog("Re-Processed Look-Pose: %s", rAIM.m_FilePath.c_str());
  667.                                                         break;
  668.                                                 }
  669.                                         }
  670.                                 }
  671.                                 else
  672.                                 {
  673.                                         CryWarning(VALIDATOR_MODULE_ANIMATION, VALIDATOR_WARNING, "Could not process aim poses from '%s' because could not find a model associated to it.", rAIM.m_FilePath.c_str());
  674.                                 }
  675.                         }
  676.  
  677.                         if (g_pCharacterManager->m_pStreamingListener)
  678.                         {
  679.                                 g_pCharacterManager->m_pStreamingListener->NotifyAnimReloaded(id);
  680.                         }
  681.  
  682.                         return status ? CR_RELOAD_SUCCEED : CR_RELOAD_FAILED;
  683.                 }
  684.         }
  685.  
  686.         //asset not found in the AIM-array
  687.         //now check the CAF array
  688.         uint32 numCAF = m_arrGlobalCAF.size();
  689.         for (uint32 id = 0; id < numCAF; id++)
  690.         {
  691.                 GlobalAnimationHeaderCAF& rCAF = m_arrGlobalCAF[id];
  692.                 if (rCAF.m_FilePathCRC32 == nCRC32)
  693.                 {
  694.                         assert(!strcmp(rCAF.GetFilePath(), szFilePathCAF));
  695.                         rCAF.m_nControllers = 0;
  696.                         int status = rCAF.LoadCAF();
  697.                         if (status)
  698.                         {
  699.                                 uint32 numBSpaces = m_arrGlobalLMG.size();
  700.                                 for (uint32 bs = 0; bs < numBSpaces; bs++)
  701.                                 {
  702.                                         m_arrGlobalLMG[bs].m_DimPara[0].m_nInitialized = 0;
  703.                                         m_arrGlobalLMG[bs].m_DimPara[1].m_nInitialized = 0;
  704.                                         m_arrGlobalLMG[bs].m_DimPara[2].m_nInitialized = 0;
  705.                                         m_arrGlobalLMG[bs].m_DimPara[3].m_nInitialized = 0;
  706.                                 }
  707.                                 CryLog("Hot loaded animation CAF-file: %s", rCAF.GetFilePath());
  708.                         }
  709.                         else
  710.                         {
  711.                                 gEnv->pLog->LogError("CAF Reloading failed: %s", szFilePathCAF);
  712.                         }
  713.  
  714.                         if (g_pCharacterManager->m_pStreamingListener)
  715.                         {
  716.                                 g_pCharacterManager->m_pStreamingListener->NotifyAnimReloaded(id);
  717.                         }
  718.  
  719.                         return status != 0 ? CR_RELOAD_SUCCEED : CR_RELOAD_FAILED;
  720.                 }
  721.         }
  722.  
  723.         return CR_RELOAD_GAH_NOT_IN_ARRAY;
  724. }
  725.  
  726. int CAnimationManager::ReloadLMG(const char* szFilePath)
  727. {
  728.         CAnimationSet* pAnimationSet = g_pCharacterManager->GetAnimationSetUsedInCharEdit();
  729.         if (pAnimationSet == 0)
  730.         {
  731.                 gEnv->pLog->LogError("BlendSpace reloading failed: %s", szFilePath);
  732.                 return -1;
  733.         }
  734.  
  735.         uint32 nCRC32 = CCrc32::ComputeLowercase(szFilePath);
  736.  
  737.         uint32 numBlendSpaces = m_arrGlobalLMG.size();
  738.         for (uint32 id = 0; id < numBlendSpaces; id++)
  739.         {
  740.                 GlobalAnimationHeaderLMG& rBlendSpace = m_arrGlobalLMG[id];
  741.                 if (rBlendSpace.m_FilePathCRC32 == nCRC32)
  742.                 {
  743.                         assert(!strcmp(rBlendSpace.GetFilePath(), szFilePath));
  744.                         bool status = false;
  745. #ifdef EDITOR_PCDEBUGCODE
  746.                         stack_string path = szFilePath;
  747.                         path.MakeLower();
  748.                         CachedBSPACES::iterator it = m_cachedBSPACES.find(path);
  749.  
  750.                         if (it != m_cachedBSPACES.end())
  751.                         {
  752.                                 XmlNodeRef root = gEnv->pSystem->LoadXmlFromBuffer(it->second.data(), it->second.size());
  753.                                 if (root)
  754.                                 {
  755.                                         status = rBlendSpace.LoadFromXML(pAnimationSet, root);
  756.                                         if (!status)
  757.                                         {
  758.                                                 gEnv->pLog->LogError("BlendSpace reloading failed: %s", szFilePath);
  759.                                         }
  760.                                 }
  761.                                 else
  762.                                 {
  763.                                         gEnv->pLog->LogError("Failed to parse cached XML: %s", szFilePath);
  764.                                 }
  765.                         }
  766.                         else
  767. #endif
  768.                         {
  769.                                 status = rBlendSpace.LoadAndParseXML(pAnimationSet, 1);
  770.                                 if (status)
  771.                                         CryLog("Hot loaded animation BlendSpace-file: %s", szFilePath);
  772.                                 else
  773.                                         gEnv->pLog->LogError("BlendSpace reloading failed: %s", szFilePath);
  774.                         }
  775.  
  776.                         if (g_pCharacterManager->m_pStreamingListener)
  777.                         {
  778.                                 g_pCharacterManager->m_pStreamingListener->NotifyAnimReloaded(id);
  779.                         }
  780.                         return status;
  781.                 }
  782.         }
  783.  
  784.         gEnv->pLog->LogError("BlendSpace reloading failed: %s", szFilePath);
  785.         return -1;
  786. }
  787.  
  788. uint32 CAnimationManager::GetDBACRC32fromFilePath(const char* szFilePathCAF)
  789. {
  790.         uint32 nCRC32 = CCrc32::ComputeLowercase(szFilePathCAF);
  791.  
  792.         uint32 numCAF = m_arrGlobalCAF.size();
  793.         for (uint32 id = 0; id < numCAF; id++)
  794.         {
  795.                 GlobalAnimationHeaderCAF& rCAF = m_arrGlobalCAF[id];
  796.                 if (rCAF.m_FilePathCRC32 == nCRC32)
  797.                         return rCAF.m_FilePathDBACRC32;
  798.         }
  799.         return 0;
  800. }
  801.  
  802. bool CAnimationManager::IsDatabaseInMemory(uint32 nDBACRC32)
  803. {
  804.         size_t numDBA_Files = m_arrGlobalHeaderDBA.size();
  805.         for (uint32 d = 0; d < numDBA_Files; d++)
  806.         {
  807.                 if (nDBACRC32 == m_arrGlobalHeaderDBA[d].m_FilePathDBACRC32)
  808.                         return m_arrGlobalHeaderDBA[d].InMemory();
  809.         }
  810.         return 0;
  811. }
  812.  
  813. //------------------------------------------------------------------------------
  814. // Unloads animation from memory and remove
  815. //------------------------------------------------------------------------------
  816. void CAnimationManager::UnloadAnimationCAF(GlobalAnimationHeaderCAF& rCAF)
  817. {
  818.         if (Console::GetInst().ca_UnloadAnimationCAF == 0)
  819.                 return;
  820.         uint32 requested = rCAF.IsAssetRequested();
  821.         if (requested)
  822.                 return;
  823.         if (rCAF.m_nControllers2 == 0)
  824.                 return;
  825.  
  826.         assert(rCAF.GetControllersCount());
  827.  
  828.         rCAF.ClearControllers();
  829.  
  830.         if (g_pCharacterManager->m_pStreamingListener)
  831.         {
  832.                 int32 globalID = GetGlobalIDbyFilePath_CAF(rCAF.GetFilePath());
  833.                 g_pCharacterManager->m_pStreamingListener->NotifyAnimUnloaded(globalID);
  834.         }
  835.  
  836.         //      g_pISystem->Warning( VALIDATOR_MODULE_ANIMATION,VALIDATOR_WARNING, VALIDATOR_FLAG_FILE,0,       "UnloadingAsset: Name: %s",rCAF.GetFilePath() );
  837. }
  838.  
  839. void CAnimationManager::UnloadAnimationAIM(int nGLobalAnimID)
  840. {
  841.         assert(m_arrGlobalAIM[nGLobalAnimID].GetControllersCount());
  842.         m_arrGlobalAIM[nGLobalAnimID].ClearControllers();
  843. }
  844.  
  845. //struct AnimSearchHelper {
  846. //
  847. //      typedef std::vector<int> TIndexVector;
  848. //      typedef std::map<uint32 /*crc*/, TIndexVector*/*vector of indexes*/> TFoldersVector;
  849. //
  850. //      void AddAnimation(uint32 crc, uint32 gahIndex);
  851. //      void AddAnimation(const string& path, uint32 gahIndex);
  852. //
  853. //      TIndexVector * GetAnimationsVector(uint32 crc);
  854. //      TIndexVector * GetAnimationsVector(const string& path);
  855. //
  856. //};
  857.  
  858. bool AnimSearchHelper::AddAnimation(uint32 crc, uint32 gahIndex)
  859. {
  860.         bool newPath = false;
  861.         TIndexVector* vect = GetAnimationsVector(crc);
  862.         if (!vect)
  863.         {
  864.                 vect = new TIndexVector;
  865.                 m_AnimationsMap[crc] = vect;
  866.                 newPath = true;
  867.         }
  868.  
  869.         vect->push_back(gahIndex);
  870.         return newPath;
  871. }
  872.  
  873. void AnimSearchHelper::AddAnimation(const string& path, uint32 gahIndex)
  874. {
  875.         stack_string pathDir = PathUtil::GetPathWithoutFilename(path);
  876.         PathUtil::ToUnixPath(pathDir);
  877.         if (strcmp(pathDir, "animations/human/male/behavior/fear/") == 0)
  878.                 int A = 0;
  879.         if (strcmp(pathDir, "animations\\human\\male\\behavior\\fear\\") == 0)
  880.                 int A = 0;
  881.  
  882.         uint32 crc = CCrc32::ComputeLowercase(pathDir);
  883.         if (AddAnimation(crc, gahIndex))
  884.         {
  885.                 for (int32 lastSlashPos = pathDir.rfind('/'); lastSlashPos >= 0; lastSlashPos = pathDir.rfind('/', lastSlashPos - 1))
  886.                 {
  887.                         uint32 parentDirCRC = CCrc32::ComputeLowercase(pathDir, lastSlashPos + 1);
  888.                         TSubFolderCrCVector* pSubFolderVec = NULL;
  889.                         TSubFoldersMap::iterator parentFolderIter = m_SubFoldersMap.find(parentDirCRC);
  890.                         if (parentFolderIter == m_SubFoldersMap.end())
  891.                         {
  892.                                 pSubFolderVec = new TSubFolderCrCVector;
  893.                                 m_SubFoldersMap[parentDirCRC] = pSubFolderVec;
  894.                         }
  895.                         else
  896.                         {
  897.                                 pSubFolderVec = parentFolderIter->second;
  898.                         }
  899.  
  900.                         pSubFolderVec->push_back(crc);
  901.                 }
  902.         }
  903. }
  904.  
  905. AnimSearchHelper::TSubFolderCrCVector* AnimSearchHelper::GetSubFoldersVector(uint32 crc)
  906. {
  907.         TSubFoldersMap::iterator parentFolderIter = m_SubFoldersMap.find(crc);
  908.         if (parentFolderIter != m_SubFoldersMap.end())
  909.         {
  910.                 return parentFolderIter->second;
  911.         }
  912.         else
  913.         {
  914.                 return NULL;
  915.         }
  916. }
  917.  
  918. AnimSearchHelper::TIndexVector* AnimSearchHelper::GetAnimationsVector(uint32 crc)
  919. {
  920.         TFoldersVector::iterator it = m_AnimationsMap.find(crc);
  921.  
  922.         if (it != m_AnimationsMap.end())
  923.                 return it->second;
  924.  
  925.         return 0;
  926. }
  927.  
  928. AnimSearchHelper::TIndexVector* AnimSearchHelper::GetAnimationsVector(const string& path)
  929. {
  930.         uint32 crc = CCrc32::ComputeLowercase(path);
  931.         return GetAnimationsVector(crc);
  932. }
  933.  
  934. void AnimSearchHelper::Clear()
  935. {
  936.         for (TFoldersVector::iterator it = m_AnimationsMap.begin(), end = m_AnimationsMap.end(); it != end; ++it)
  937.                 delete it->second;
  938.         for (TSubFoldersMap::iterator it = m_SubFoldersMap.begin(), end = m_SubFoldersMap.end(); it != end; ++it)
  939.                 delete it->second;
  940.         m_AnimationsMap.clear();
  941.         m_SubFoldersMap.clear();
  942. }
  943.  
  944. size_t CAnimationManager::GetSizeOfDBA()
  945. {
  946.         size_t nSize = 0;
  947.         uint32 numDBAs = m_arrGlobalHeaderDBA.size();
  948.         for (uint32 i = 0; i < numDBAs; i++)
  949.                 nSize += m_arrGlobalHeaderDBA[i].SizeOf_DBA();
  950.         return nSize;
  951. }
  952.  
  953. void CAnimationManager::GetMemoryUsage(class ICrySizer* pSizer) const
  954. {
  955.         SIZER_SUBCOMPONENT_NAME(pSizer, "AnimationKeys");
  956.         pSizer->AddObject(m_AnimationMapCAF);
  957.         pSizer->AddObject(m_arrGlobalCAF);
  958.         pSizer->AddObject(m_arrGlobalAIM);
  959.         pSizer->AddObject(m_arrGlobalLMG);
  960.         pSizer->AddObject(m_arrGlobalHeaderDBA);
  961. }
  962.  
  963. void CAnimationManager::DebugAnimUsage(uint32 printtxt)
  964. {
  965.         DEFINE_PROFILER_FUNCTION();
  966.  
  967. #ifndef CONSOLE_CONST_CVAR_MODE
  968.         //      if (Console::GetInst().ca_DebugAnimMemTracking==0)
  969.         //              return;
  970.         if (m_shuttingDown)
  971.                 return;
  972.         float fRed[4] = { 1, 0, 0, 1 };
  973.         float fGreen[4] = { 0, 1, 0, 1 };
  974.         float fBlue[4] = { 0, 0, 1, 1 };
  975.  
  976.         size_t numDBA_Files = m_arrGlobalHeaderDBA.size();
  977.  
  978.         for (uint32 d = 0; d < numDBA_Files; d++)
  979.                 m_arrGlobalHeaderDBA[d].m_nEmpty = 1;
  980.  
  981.         for (uint32 x = 0; x < numDBA_Files; x++)
  982.         {
  983.                 uint32 biggest = 0;
  984.                 int32 b = -1;
  985.                 for (uint32 d = 0; d < numDBA_Files; d++)
  986.                 {
  987.                         uint32 nUsed = m_arrGlobalHeaderDBA[d].m_nEmpty;
  988.                         size_t nSizeOfDBA = m_arrGlobalHeaderDBA[d].SizeOf_DBA();
  989.                         if (biggest < nSizeOfDBA && nUsed)
  990.                         {
  991.                                 biggest = nSizeOfDBA;
  992.                                 b = d;
  993.                         }
  994.                 }
  995.  
  996.                 if (b > -1)
  997.                 {
  998.                         m_arrGlobalHeaderDBA[b].m_nEmpty = 0;
  999.                         const char* pName = m_arrGlobalHeaderDBA[b].m_strFilePathDBA;
  1000.                         uint32 nDBACRC32 = m_arrGlobalHeaderDBA[b].m_FilePathDBACRC32;
  1001.                         uint32 nUsedAssets = m_arrGlobalHeaderDBA[b].m_nUsedAnimations;
  1002.                         size_t nSizeOfDBA = m_arrGlobalHeaderDBA[b].SizeOf_DBA();
  1003.                         uint32 nLastUsedTimeSec = m_arrGlobalHeaderDBA[b].m_nLastUsedTimeDelta / 1000;
  1004.                         uint32 nLock = m_arrGlobalHeaderDBA[b].m_bDBALock;
  1005.  
  1006.                         if (m_arrGlobalHeaderDBA[b].m_pDatabaseInfo == 0)
  1007.                         {
  1008.                                 //      fColorGreen[3]=0.4f;
  1009.                                 //      g_pAuxGeom->Draw2dLabel( 1,g_YLine, 0.9f, fColorGreen, false,"UsedAssets: %04d  nTCount: %08x  Size: %08d  FilePathDBA: %s",nUsedAssets,nTCount,nSizeOfDBA,pName );
  1010.                                 //      g_YLine+=9.0f;
  1011.                         }
  1012.                         else
  1013.                         {
  1014.                                 float fColor[4] = { 0, 1, 0, 1 };
  1015.                                 if (nLock)
  1016.                                 {
  1017.                                         fColor[0] = 1.0f;
  1018.                                         fColor[1] = 0.0f;
  1019.                                 }
  1020.                                 if (printtxt)
  1021.                                 {
  1022.                                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 1.1f, fColor, false, "UsedAssets: %04d  nTCount: %u  Size: %" PRISIZE_T "  FilePathDBA: %s", nUsedAssets, nLastUsedTimeSec, nSizeOfDBA, pName);
  1023.                                         g_YLine += 11.0f;
  1024.                                 }
  1025.                         }
  1026.                 }
  1027.         }
  1028.         g_YLine += 16.0f;
  1029.  
  1030.         size_t nAnimationManager = sizeof(CAnimationManager);
  1031.  
  1032.         size_t nMap = m_AnimationMapCAF.GetAllocMemSize();
  1033.  
  1034.         size_t nFilePathSize = 0;
  1035.  
  1036.         {
  1037.                 uint32 numCAF = m_arrGlobalCAF.size();
  1038.                 for (uint32 i = 0; i < numCAF; i++)
  1039.                         nFilePathSize += m_arrGlobalCAF[i].m_FilePath.capacity();
  1040.                 uint32 numAIM = m_arrGlobalAIM.size();
  1041.                 for (uint32 i = 0; i < numAIM; i++)
  1042.                         nFilePathSize += m_arrGlobalAIM[i].m_FilePath.capacity();
  1043.                 uint32 numLMG = m_arrGlobalLMG.size();
  1044.                 for (uint32 i = 0; i < numLMG; i++)
  1045.                         nFilePathSize += m_arrGlobalLMG[i].m_FilePath.capacity();
  1046.  
  1047.                 numCAF = m_arrGlobalCAF.capacity();
  1048.                 numAIM = m_arrGlobalAIM.capacity();
  1049.                 numLMG = m_arrGlobalLMG.capacity();
  1050.  
  1051.                 size_t nEmptyHeaderSize = 0;
  1052.                 nEmptyHeaderSize += numCAF * sizeof(GlobalAnimationHeaderCAF);
  1053.                 nEmptyHeaderSize += numAIM * sizeof(GlobalAnimationHeaderAIM);
  1054.                 nEmptyHeaderSize += numLMG * sizeof(GlobalAnimationHeaderLMG);
  1055.                 if (printtxt)
  1056.                 {
  1057.                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.0f, fRed, false, "size of path names: %" PRISIZE_T " bytes     Empty Headers: %" PRISIZE_T " bytes", nFilePathSize, nEmptyHeaderSize);
  1058.                         g_YLine += 16.0f;
  1059.                 }
  1060.         }
  1061.  
  1062.         //calculate size of DBAs
  1063.         size_t nDBAalloc = GetSizeOfDBA();
  1064.         nAnimationManager += nDBAalloc;
  1065.         if (printtxt)
  1066.         {
  1067.                 g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.0f, fRed, false, "DBA: %" PRISIZE_T " KBytes   map: %" PRISIZE_T " KBytes", nDBAalloc / 1024, nMap / 1024);
  1068.                 g_YLine += 16.0f;
  1069.         }
  1070.  
  1071.         uint32 nUsedCAFs = 0;
  1072.         {
  1073.                 uint32 numCAF = m_arrGlobalCAF.size();
  1074.                 size_t nSize = m_arrGlobalCAF.get_alloc_size() + nMap;
  1075.                 for (uint32 i = 0; i < numCAF; i++)
  1076.                         nSize += m_arrGlobalCAF[i].SizeOfCAF();
  1077.                 uint32 nNumHeaders = m_arrGlobalCAF.size();
  1078.                 uint32 nLoaded = 0;
  1079.                 uint32 nSizeOfLoadedKeys = 0;
  1080.                 for (uint32 i = 0; i < nNumHeaders; i++)
  1081.                 {
  1082.                         uint32 IsAssetLoaded = m_arrGlobalCAF[i].IsAssetLoaded();
  1083.                         uint32 IsDBAFile = m_arrGlobalCAF[i].m_FilePathDBACRC32;
  1084.                         if (m_arrGlobalCAF[i].m_FilePathDBACRC32 == -1)
  1085.                                 IsDBAFile = 0;
  1086.  
  1087.                         if (IsAssetLoaded && IsDBAFile == 0)
  1088.                         {
  1089.                                 nLoaded++;
  1090.                                 uint32 nSizeOfCAF = m_arrGlobalCAF[i].SizeOfCAF();
  1091.                                 nSizeOfLoadedKeys += nSizeOfCAF;
  1092.  
  1093.                                 uint32 nRef_at_Runtime = m_arrGlobalCAF[i].m_nRef_at_Runtime;
  1094.  
  1095.                                 if (printtxt && Console::GetInst().ca_DebugAnimUsage == 2)
  1096.                                 {
  1097.                                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 1.1f, fGreen, false, "CafInMemory: %7d ref: %5d FilePath: %s", nSizeOfCAF, nRef_at_Runtime, m_arrGlobalCAF[i].GetFilePath());
  1098.                                         g_YLine += 11.0f;
  1099.                                 }
  1100.  
  1101.                                 if (printtxt && Console::GetInst().ca_DebugAnimUsage & 4)
  1102.                                 {
  1103.                                         CryLogAlways("CafInMemory: %07u FilePath: %s", nSizeOfCAF, m_arrGlobalCAF[i].GetFilePath());
  1104.                                 }
  1105.                         }
  1106.                         nUsedCAFs += (m_arrGlobalCAF[i].m_nTouchedCounter != 0);
  1107.                 }
  1108.  
  1109.                 if (printtxt && Console::GetInst().ca_DebugAnimUsage & 4)
  1110.                 {
  1111.                         CryLogAlways("nSizeOfLoadedKeys: %07u", nSizeOfLoadedKeys);
  1112.                         Console::GetInst().ca_DebugAnimUsage &= 3;
  1113.                 }
  1114.                 if (printtxt)
  1115.                 {
  1116.                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.0f, fRed, false, "CAF: %04d    Loaded: %04d    Used: %04d   Memory: %05" PRISIZE_T " / %05d KBytes", nNumHeaders, nLoaded, nUsedCAFs, nSize / 1024, nSizeOfLoadedKeys / 1024);
  1117.                         g_YLine += 16.0f;
  1118.                 }
  1119.                 nAnimationManager += nSize;
  1120.         }
  1121.  
  1122.         {
  1123.                 uint32 numAIM = m_arrGlobalAIM.size();
  1124.                 size_t nSize = m_arrGlobalAIM.get_alloc_size();
  1125.                 for (uint32 i = 0; i < numAIM; i++)
  1126.                         nSize += m_arrGlobalAIM[i].SizeOfAIM();
  1127.  
  1128.                 uint32 nNumHeaders = m_arrGlobalAIM.size();
  1129.                 uint32 nLoaded = 0;
  1130.                 uint32 nUsed = 0;
  1131.                 for (uint32 i = 0; i < nNumHeaders; i++)
  1132.                 {
  1133.                         nLoaded += (m_arrGlobalAIM[i].IsAssetLoaded() != 0);
  1134.                         nUsed += (m_arrGlobalAIM[i].m_nTouchedCounter != 0);
  1135.                 }
  1136.                 if (printtxt)
  1137.                 {
  1138.                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.0f, fRed, false, "AIM: %04d    Loaded: %04d    Used: %04d   Memory: %05" PRISIZE_T " KBytes", nNumHeaders, nLoaded, nUsed, nSize / 1024);
  1139.                         g_YLine += 16.0f;
  1140.                 }
  1141.                 nAnimationManager += nSize;
  1142.         }
  1143.  
  1144.         {
  1145.                 uint32 numLMG = m_arrGlobalLMG.size();
  1146.                 size_t nSize = m_arrGlobalLMG.get_alloc_size();
  1147.                 for (uint32 i = 0; i < numLMG; i++)
  1148.                         nSize += m_arrGlobalLMG[i].SizeOfLMG();
  1149.  
  1150.                 uint32 nNumHeaders = m_arrGlobalLMG.size();
  1151.                 uint32 nLoaded = 0;
  1152.                 uint32 nUsed = 0;
  1153.                 for (uint32 i = 0; i < nNumHeaders; i++)
  1154.                 {
  1155.                         nLoaded += (m_arrGlobalLMG[i].IsAssetLoaded() != 0);
  1156.                         nUsed += (m_arrGlobalLMG[i].m_nTouchedCounter != 0);
  1157.                 }
  1158.                 if (printtxt)
  1159.                 {
  1160.                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.0f, fRed, false, "Blendspace: %04d    Loaded: %04d    Used: %04d  Memory: %05" PRISIZE_T "KBytes", nNumHeaders, nLoaded, nUsed, nSize / 1024);
  1161.                         g_YLine += 16.0f;
  1162.                 }
  1163.                 nAnimationManager += nSize;
  1164.         }
  1165.  
  1166.         if (printtxt)
  1167.         {
  1168.                 CControllerDefragHeap::Stats stats = g_controllerHeap.GetStats();
  1169.                 size_t moveableFree = stats.defragStats.nCapacity - stats.defragStats.nInUseSize;
  1170.                 g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.0f, fRed, false, "Defrag heap: %" PRISIZE_T " KB moveable %" PRISIZE_T "KB fixed %.2f%% frag", stats.defragStats.nInUseSize / 1024, stats.bytesInFixedAllocs / 1024,
  1171.                                         100.0f * ((moveableFree - stats.defragStats.nLargestFreeBlockSize) / (float)stats.defragStats.nCapacity));
  1172.                 g_YLine += 16.0f;
  1173.         }
  1174.  
  1175.         m_AnimMemoryTracker.m_nAnimsCurrent = nAnimationManager;
  1176.  
  1177.         m_AnimMemoryTracker.m_nGlobalCAFs = m_arrGlobalCAF.size();
  1178.         m_AnimMemoryTracker.m_nUsedGlobalCAFs = nUsedCAFs;
  1179.  
  1180.         if (m_AnimMemoryTracker.m_nAnimsMax < nAnimationManager)
  1181.                 m_AnimMemoryTracker.m_nAnimsMax = nAnimationManager;
  1182.  
  1183.         uint64 average = 0;
  1184.         if (m_AnimMemoryTracker.m_nAnimsCounter || m_AnimMemoryTracker.m_nAnimsCurrent > 7211000)
  1185.         {
  1186.                 m_AnimMemoryTracker.m_nAnimsCounter++;
  1187.                 m_AnimMemoryTracker.m_nAnimsAdd += nAnimationManager;
  1188.                 average = m_AnimMemoryTracker.m_nAnimsAdd / m_AnimMemoryTracker.m_nAnimsCounter;
  1189.         }
  1190.  
  1191.         static uint32 mupdate = 0x1f;
  1192.         mupdate++;
  1193.         mupdate &= 0x7f;
  1194.         if (mupdate == 0)
  1195.                 g_pCharacterManager->TrackMemoryOfModels();
  1196.  
  1197.         if (printtxt)
  1198.         {
  1199.                 g_YLine += 10.0f;
  1200.                 g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.2f, fBlue, false, "nAnimsPerFrame: %4d  nAnimsMax: %4d nAnimsAvrg: %4d", m_AnimMemoryTracker.m_nAnimsCurrent / 1024, m_AnimMemoryTracker.m_nAnimsMax / 1024, (uint32)(average / 1024));
  1201.                 g_YLine += 25.0f;
  1202.                 g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.2f, fRed, false, "CharInstances:%3d (Mem: %4dKB) SkinInstances:%3d (Mem: %4dKB)  Models:%3d (Mem: %4dKB)", m_AnimMemoryTracker.m_numTCharInstances, m_AnimMemoryTracker.m_nTotalCharMemory / 1024, m_AnimMemoryTracker.m_numTSkinInstances, m_AnimMemoryTracker.m_nTotalSkinMemory / 1024, m_AnimMemoryTracker.m_numModels, m_AnimMemoryTracker.m_nTotalMMemory / 1024);
  1203.                 g_YLine += 25.0f;
  1204.                 g_pAuxGeom->Draw2dLabel(1, g_YLine, 3.0f, fRed, false, "Total: %4dKB", (m_AnimMemoryTracker.m_nTotalCharMemory + m_AnimMemoryTracker.m_nTotalSkinMemory + m_AnimMemoryTracker.m_nTotalMMemory + m_AnimMemoryTracker.m_nAnimsCurrent) / 1024);
  1205.         }
  1206. #endif
  1207. }
  1208.  
downloadAnimationManager.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