BVB Source Codes

CRYENGINE Show ICryMannequinUserParams.h Source code

Return Download CRYENGINE: download ICryMannequinUserParams.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __I_CRY_MANNEQUIN_USER_PARAMS__H__
  4. #define __I_CRY_MANNEQUIN_USER_PARAMS__H__
  5.  
  6. struct IMannequinUserParams
  7. {
  8.         virtual ~IMannequinUserParams() {}
  9.         virtual void Init(const SControllerDef& controllerDef) = 0;
  10. };
  11.  
  12. class CMannequinUserParamId
  13. {
  14. public:
  15.         CMannequinUserParamId(const SControllerDef& controllerDef, const uint32 paramType)
  16.                 : m_controllerDefPathCrc(0)
  17.                 , m_paramType(paramType)
  18.         {
  19.                 m_controllerDefPathCrc = controllerDef.m_filename.crc;
  20.         }
  21.  
  22.         bool operator==(const CMannequinUserParamId& rhs) const
  23.         {
  24.                 return ((m_controllerDefPathCrc == rhs.m_controllerDefPathCrc) && (m_paramType == rhs.m_paramType));
  25.         }
  26.  
  27.         bool operator<(const CMannequinUserParamId& rhs) const
  28.         {
  29.                 if (m_controllerDefPathCrc < rhs.m_controllerDefPathCrc)
  30.                 {
  31.                         return true;
  32.                 }
  33.                 else if (m_controllerDefPathCrc == rhs.m_controllerDefPathCrc)
  34.                 {
  35.                         return (m_paramType < rhs.m_paramType);
  36.                 }
  37.  
  38.                 return false;
  39.         }
  40.  
  41.         uint32 GetControllerDefCrc() const { return m_controllerDefPathCrc; }
  42.  
  43. private:
  44.         uint32 m_controllerDefPathCrc;
  45.         uint32 m_paramType;
  46. };
  47.  
  48. class CMannequinUserParamsManager
  49. {
  50. public:
  51.         CMannequinUserParamsManager()
  52.                 : m_autoIncValue(0)
  53.         {}
  54.  
  55.         ~CMannequinUserParamsManager()
  56.         {
  57.                 Clear();
  58.         }
  59.  
  60.         void Clear()
  61.         {
  62.                 for (TMannequinOwnedUserParams::iterator it = m_ownedUserParams.begin(); it != m_ownedUserParams.end(); ++it)
  63.                 {
  64.                         IMannequinUserParams* pParams = *it;
  65.                         delete pParams;
  66.                 }
  67.  
  68.                 m_userParams.clear();
  69.                 m_ownedUserParams.clear();
  70.         }
  71.  
  72.         void ReloadAll(IAnimationDatabaseManager& animationDatabaseManager)
  73.         {
  74.                 static CTagDefinition s_dummyTagDefinition;
  75.                 static SControllerDef s_dummyControllerDef(s_dummyTagDefinition, s_dummyTagDefinition, s_dummyTagDefinition);
  76.  
  77.                 for (TMannequinUserParams::iterator it = m_userParams.begin(); it != m_userParams.end(); ++it)
  78.                 {
  79.                         SMannequinParamEntry& entry = *it;
  80.                         const CMannequinUserParamId& mannequinUserParamId = entry.paramId;
  81.                         const uint32 controllerDefCrc = mannequinUserParamId.GetControllerDefCrc();
  82.                         const SControllerDef* pControllerDef = animationDatabaseManager.FindControllerDef(controllerDefCrc);
  83.                         CRY_ASSERT(pControllerDef != NULL);
  84.                         pControllerDef = pControllerDef ? pControllerDef : &s_dummyControllerDef;
  85.  
  86.                         IMannequinUserParams* pParams = entry.pParams;
  87.                         pParams->Init(*pControllerDef);
  88.                 }
  89.         }
  90.  
  91.         template<typename T>
  92.         const T* FindOrCreateParams(const IActionController* pActionController)
  93.         {
  94.                 if (pActionController == NULL)
  95.                 {
  96.                         return NULL;
  97.                 }
  98.  
  99.                 const SAnimationContext& animationContext = pActionController->GetContext();
  100.                 const SControllerDef& controllerDef = animationContext.controllerDef;
  101.  
  102.                 return FindOrCreateParams<T>(controllerDef);
  103.         }
  104.  
  105.         template<typename T>
  106.         const T* FindOrCreateParams(const SControllerDef& controllerDef)
  107.         {
  108.                 static uint32 s_mannequinParamType = GetAutoIncParamTypeValue();
  109.                 const CMannequinUserParamId mannequinUserParamId(controllerDef, s_mannequinParamType);
  110.  
  111.                 {
  112.                         const IMannequinUserParams* pParams = FindParams(mannequinUserParamId);
  113.                         if (pParams != NULL)
  114.                         {
  115.                                 return static_cast<const T*>(pParams);
  116.                         }
  117.                 }
  118.  
  119.                 T* pParams = new T();
  120.  
  121.                 pParams->Init(controllerDef);
  122.                 AddParams(mannequinUserParamId, pParams, eMPO_ManagerOwnership);
  123.  
  124.                 return pParams;
  125.         }
  126.  
  127.         template<typename T>
  128.         void RegisterParams(const IActionController* pActionController, IMannequinUserParams* pParams)
  129.         {
  130.                 if (pActionController == NULL)
  131.                 {
  132.                         return;
  133.                 }
  134.  
  135.                 const SAnimationContext& animationContext = pActionController->GetContext();
  136.                 const SControllerDef& controllerDef = animationContext.controllerDef;
  137.  
  138.                 RegisterParams<T>(controllerDef, pParams);
  139.         }
  140.  
  141.         template<typename T>
  142.         void RegisterParams(const SControllerDef& controllerDef, IMannequinUserParams* pParams)
  143.         {
  144.                 if (pParams == NULL)
  145.                 {
  146.                         return;
  147.                 }
  148.  
  149.                 static uint32 s_mannequinParamType = GetAutoIncParamTypeValue();
  150.                 const CMannequinUserParamId mannequinUserParamId(controllerDef, s_mannequinParamType);
  151.  
  152.                 const IMannequinUserParams* pParamsOther = FindParams(mannequinUserParamId);
  153.                 if (pParamsOther != NULL)
  154.                 {
  155.                         CRY_ASSERT(pParams == pParamsOther);
  156.                         return;
  157.                 }
  158.  
  159.                 pParams->Init(controllerDef);
  160.                 AddParams(mannequinUserParamId, pParams, eMPO_ExternalOwnership);
  161.         }
  162.  
  163. protected:
  164.         const IMannequinUserParams* FindParams(const CMannequinUserParamId& paramId) const
  165.         {
  166.                 TMannequinUserParams::const_iterator cit = std::lower_bound(m_userParams.begin(), m_userParams.end(), SMannequinParamEntry(paramId));
  167.                 const bool found = (cit != m_userParams.end()) && (cit->paramId == paramId);
  168.                 return (found) ? cit->pParams : NULL;
  169.         }
  170.  
  171.         enum EMannequinParamsOwnership
  172.         {
  173.                 eMPO_ExternalOwnership,
  174.                 eMPO_ManagerOwnership
  175.         };
  176.         void AddParams(const CMannequinUserParamId& paramId, IMannequinUserParams* pParams, const EMannequinParamsOwnership ownership)
  177.         {
  178.                 const SMannequinParamEntry entry(paramId, pParams);
  179.                 m_userParams.insert(std::lower_bound(m_userParams.begin(), m_userParams.end(), entry), entry);
  180.  
  181.                 if (ownership == eMPO_ManagerOwnership)
  182.                 {
  183.                         m_ownedUserParams.push_back(pParams);
  184.                 }
  185.         }
  186.  
  187. private:
  188.         uint32 GetAutoIncParamTypeValue()
  189.         {
  190.                 m_autoIncValue++;
  191.                 return m_autoIncValue;
  192.         }
  193.  
  194. private:
  195.         struct SMannequinParamEntry
  196.         {
  197.                 CMannequinUserParamId paramId;
  198.                 IMannequinUserParams* pParams;
  199.  
  200.                 SMannequinParamEntry(const CMannequinUserParamId& paramId_, IMannequinUserParams* pParams_ = NULL)
  201.                         : paramId(paramId_)
  202.                         , pParams(pParams_)
  203.                 {
  204.                 }
  205.  
  206.                 bool operator<(const SMannequinParamEntry& rhs) const
  207.                 {
  208.                         return (paramId < rhs.paramId);
  209.                 }
  210.         };
  211.  
  212.         typedef DynArray<SMannequinParamEntry>  TMannequinUserParams;
  213.         typedef DynArray<IMannequinUserParams*> TMannequinOwnedUserParams;
  214.  
  215.         TMannequinUserParams      m_userParams;
  216.         TMannequinOwnedUserParams m_ownedUserParams;
  217.         uint32                    m_autoIncValue;
  218. };
  219.  
  220. template<typename T, T invalidValue>
  221. struct TMannequinAutoInit
  222. {
  223. public:
  224.         TMannequinAutoInit()
  225.                 : m_value(invalidValue)
  226.         {
  227.         }
  228.  
  229.         const TMannequinAutoInit<T, invalidValue>& operator=(const T value)
  230.         {
  231.                 m_value = value;
  232.                 return *this;
  233.         }
  234.  
  235.         operator const T() const
  236.         {
  237.                 return m_value;
  238.         }
  239.  
  240.         bool IsValid() const
  241.         {
  242.                 return (m_value != invalidValue);
  243.         }
  244.  
  245. private:
  246.         T m_value;
  247. };
  248.  
  249. typedef TMannequinAutoInit<TagID, TAG_ID_INVALID>           TagIDAutoInit;
  250. typedef TMannequinAutoInit<TagGroupID, GROUP_ID_NONE>       TagGroupIDAutoInit;
  251. typedef TMannequinAutoInit<FragmentID, FRAGMENT_ID_INVALID> FragmentIDAutoInit;
  252. typedef TMannequinAutoInit<TagID, SCOPE_ID_INVALID>         ScopeIDAutoInit;
  253. typedef TMannequinAutoInit<TagID, SCOPE_CONTEXT_ID_INVALID> ContextIDAutoInit;
  254.  
  255. #define MANNEQUIN_USER_PARAMS__IMPL_IMPL_GET_THIRD_ARG(arg1, arg2, arg3, ...) arg3
  256. #define MANNEQUIN_USER_PARAMS__IMPL_GET_THIRD_ARG(x)                          MANNEQUIN_USER_PARAMS__IMPL_IMPL_GET_THIRD_ARG x
  257. #define MANNEQUIN_USER_PARAMS__GET_THIRD_ARG(...)                             MANNEQUIN_USER_PARAMS__IMPL_GET_THIRD_ARG((__VA_ARGS__))
  258.  
  259. #define MANNEQUIN_USER_PARAMS__NOTHING
  260.  
  261. #define MANNEQUIN_USER_PARAMS__ADD_ONE(x, ...)                   + 1
  262. #define MANNEQUIN_USER_PARAMS__OPTIONAL_ARGUMENT(...)            , ## __VA_ARGS__
  263. #define MANNEQUIN_USER_PARAMS__OPTIONAL_ARGUMENT_FROM_LIST(list) MANNEQUIN_USER_PARAMS__OPTIONAL_ARGUMENT(list(MANNEQUIN_USER_PARAMS__ADD_ONE))
  264.  
  265. #define MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(list, stuff)    MANNEQUIN_USER_PARAMS__GET_THIRD_ARG(1 MANNEQUIN_USER_PARAMS__OPTIONAL_ARGUMENT_FROM_LIST(list), stuff, MANNEQUIN_USER_PARAMS__NOTHING)
  266.  
  267. #define MANNEQUIN_USER_PARAMS__EMPTY_LIST(x)
  268.  
  269. #define MANNEQUIN_USER_PARAMS__DECLARE_FRAGMENT(elem) FragmentIDAutoInit elem;
  270. #define MANNEQUIN_USER_PARAMS__INIT_FRAGMENT(elem)    elem = tagDefs.Find( # elem);
  271.  
  272. #define MANNEQUIN_USER_PARAMS__FRAGMENT_STRUCT(elementsName, elementList) \
  273.   struct elementsName                                                     \
  274.   {                                                                       \
  275.     elementList(MANNEQUIN_USER_PARAMS__DECLARE_FRAGMENT)                  \
  276.                                                                           \
  277.     void Init(const CTagDefinition &tagDefs)                              \
  278.     {                                                                     \
  279.       elementList(MANNEQUIN_USER_PARAMS__INIT_FRAGMENT)                   \
  280.     }                                                                     \
  281.   };
  282.  
  283. #define MANNEQUIN_USER_PARAMS__DECLARE_TAG(elem) TagIDAutoInit elem;
  284. #define MANNEQUIN_USER_PARAMS__INIT_TAG(elem)    elem = tagDefs.Find( # elem);
  285.  
  286. #define MANNEQUIN_USER_PARAMS__TAG_STRUCT(elementsName, elementList) \
  287.   struct elementsName                                                \
  288.   {                                                                  \
  289.     elementList(MANNEQUIN_USER_PARAMS__DECLARE_TAG)                  \
  290.                                                                      \
  291.     void Init(const CTagDefinition &tagDefs)                         \
  292.     {                                                                \
  293.       elementList(MANNEQUIN_USER_PARAMS__INIT_TAG)                   \
  294.     }                                                                \
  295.   };
  296.  
  297. #define MANNEQUIN_USER_PARAMS__DECLARE_TAGGROUP(groupElem) TagGroupIDAutoInit groupElem;
  298. #define MANNEQUIN_USER_PARAMS__INIT_TAGGROUP(groupElem)    groupElem = tagDefs.FindGroup( # groupElem);
  299.  
  300. #define MANNEQUIN_USER_PARAMS__TAGGROUP_STRUCT(elementsName, elementList) \
  301.   struct elementsName                                                     \
  302.   {                                                                       \
  303.     elementList(MANNEQUIN_USER_PARAMS__DECLARE_TAGGROUP)                  \
  304.                                                                           \
  305.     void Init(const CTagDefinition &tagDefs)                              \
  306.     {                                                                     \
  307.       elementList(MANNEQUIN_USER_PARAMS__INIT_TAGGROUP)                   \
  308.     }                                                                     \
  309.   };
  310.  
  311. #define MANNEQUIN_USER_PARAMS__DECLARE_SCOPE(elem) ScopeIDAutoInit elem;
  312. #define MANNEQUIN_USER_PARAMS__INIT_SCOPE(elem)    elem = tagDefs.Find( # elem);
  313.  
  314. #define MANNEQUIN_USER_PARAMS__SCOPE_STRUCT(elementsName, elementList) \
  315.   struct elementsName                                                  \
  316.   {                                                                    \
  317.     elementList(MANNEQUIN_USER_PARAMS__DECLARE_SCOPE)                  \
  318.                                                                        \
  319.     void Init(const CTagDefinition &tagDefs)                           \
  320.     {                                                                  \
  321.       elementList(MANNEQUIN_USER_PARAMS__INIT_SCOPE)                   \
  322.     }                                                                  \
  323.   };
  324.  
  325. #define MANNEQUIN_USER_PARAMS__FRAGTAG_STRUCT(fragmentName, fragTagTagsList, fragTagTagGroupsList)                                                     \
  326.   struct S ## fragmentName                                                                                                                             \
  327.   {                                                                                                                                                    \
  328.     S ## fragmentName()                                                                                                                                \
  329.       : pTagDefinition(NULL)                                                                                                                           \
  330.     {}                                                                                                                                                 \
  331.                                                                                                                                                        \
  332.                                                                                                                                                        \
  333.     void Init(const SControllerDef &controllerDef)                                                                                                     \
  334.     {                                                                                                                                                  \
  335.       pTagDefinition = NULL;                                                                                                                           \
  336.       fragmentID = controllerDef.m_fragmentIDs.Find( # fragmentName);                                                                                  \
  337.       if (fragmentID != FRAGMENT_ID_INVALID)                                                                                                           \
  338.       {                                                                                                                                                \
  339.         pTagDefinition = controllerDef.GetFragmentTagDef(fragmentID);                                                                                  \
  340.       }                                                                                                                                                \
  341.                                                                                                                                                        \
  342.       static CTagDefinition s_dummyTagDefinition;                                                                                                      \
  343.       pTagDefinition = pTagDefinition ? pTagDefinition : &s_dummyTagDefinition;                                                                        \
  344.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragTagTagsList, fragmentTagIDs.Init(*pTagDefinition));                                                 \
  345.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragTagTagGroupsList, fragmentTagGroupIDs.Init(*pTagDefinition));                                       \
  346.     }                                                                                                                                                  \
  347.                                                                                                                                                        \
  348.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragTagTagsList, MANNEQUIN_USER_PARAMS__FRAGMENT_STRUCT(FragmentTagIDs, fragTagTagsList));                \
  349.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragTagTagGroupsList, MANNEQUIN_USER_PARAMS__TAGGROUP_STRUCT(FragmentTagGroupIDs, fragTagTagGroupsList)); \
  350.                                                                                                                                                        \
  351.     TagIDAutoInit fragmentID;                                                                                                                          \
  352.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragTagTagsList, FragmentTagIDs fragmentTagIDs);                                                          \
  353.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragTagTagGroupsList, FragmentTagGroupIDs fragmentTagGroupIDs);                                           \
  354.     const CTagDefinition* pTagDefinition;                                                                                                              \
  355.   };                                                                                                                                                   \
  356.                                                                                                                                                        \
  357.   S ## fragmentName fragmentName;
  358.  
  359. #define MANNEQUIN_USER_PARAMS__FRAGTAG_STRUCT_INIT(fragmentName, ...) fragmentName.Init(controllerDef);
  360.  
  361. #define MANNEQUIN_USER_PARAMS__FRAGTAG_HOLDER_STRUCT(elementsName, elementList) \
  362.   struct elementsName                                                           \
  363.   {                                                                             \
  364.     elementList(MANNEQUIN_USER_PARAMS__FRAGTAG_STRUCT)                          \
  365.                                                                                 \
  366.     void Init(const SControllerDef &controllerDef)                              \
  367.     {                                                                           \
  368.       elementList(MANNEQUIN_USER_PARAMS__FRAGTAG_STRUCT_INIT)                   \
  369.     }                                                                           \
  370.                                                                                 \
  371.   };
  372.  
  373. #define MANNEQUIN_USER_PARAMS(structName, fragmentList, tagList, tagGroupList, scopeList, contextList, fragmentTagsList)                   \
  374.   struct structName                                                                                                                        \
  375.     : public IMannequinUserParams                                                                                                          \
  376.   {                                                                                                                                        \
  377.     virtual void Init(const SControllerDef &controllerDef)                                                                                 \
  378.     {                                                                                                                                      \
  379.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragmentList, fragmentIDs.Init(controllerDef.m_fragmentIDs));                               \
  380.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(tagList, tagIDs.Init(controllerDef.m_tags));                                                \
  381.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(tagGroupList, tagGroupIDs.Init(controllerDef.m_tags));                                      \
  382.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(scopeList, scopeIDs.Init(controllerDef.m_scopeIDs));                                        \
  383.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(contextList, contextIDs.Init(controllerDef.m_scopeContexts));                               \
  384.       MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragmentTagsList, fragments.Init(controllerDef));                                           \
  385.     }                                                                                                                                      \
  386.                                                                                                                                            \
  387.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragmentList, MANNEQUIN_USER_PARAMS__FRAGMENT_STRUCT(FragmentIDs, fragmentList));             \
  388.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(tagList, MANNEQUIN_USER_PARAMS__TAG_STRUCT(TagIDs, tagList));                                 \
  389.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(tagGroupList, MANNEQUIN_USER_PARAMS__TAGGROUP_STRUCT(TagGroupIDs, tagGroupList));             \
  390.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(scopeList, MANNEQUIN_USER_PARAMS__SCOPE_STRUCT(ScopeIDs, scopeList));                         \
  391.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(contextList, MANNEQUIN_USER_PARAMS__TAG_STRUCT(ContextIDs, contextList));                     \
  392.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragmentTagsList, MANNEQUIN_USER_PARAMS__FRAGTAG_HOLDER_STRUCT(Fragments, fragmentTagsList)); \
  393.                                                                                                                                            \
  394.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragmentList, FragmentIDs fragmentIDs);                                                       \
  395.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(tagList, TagIDs tagIDs);                                                                      \
  396.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(tagGroupList, TagGroupIDs tagGroupIDs);                                                       \
  397.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(scopeList, ScopeIDs scopeIDs);                                                                \
  398.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(contextList, ContextIDs contextIDs);                                                          \
  399.     MANNEQUIN_USER_PARAMS__IF_LIST_NOT_EMPTY(fragmentTagsList, Fragments fragments);                                                       \
  400.   };
  401.  
  402. #define MANNEQUIN_AUTO_CRC__DECLARE_ELEMENT(elem) uint32 elem;
  403. #define MANNEQUIN_AUTO_CRC__INIT_ELEMENT(elem)    elem = CCrc32::ComputeLowercase( # elem);
  404.  
  405. #define MANNEQUIN_AUTO_CRC(structName, crcList)   \
  406.   struct structName                               \
  407.   {                                               \
  408.     structName()                                  \
  409.       : m_initialised(false)                      \
  410.     {}                                            \
  411.                                                   \
  412.     void Init()                                   \
  413.     {                                             \
  414.       if (!m_initialised)                         \
  415.       {                                           \
  416.         crcList(MANNEQUIN_AUTO_CRC__INIT_ELEMENT) \
  417.         m_initialised = true;                     \
  418.       }                                           \
  419.     }                                             \
  420.                                                   \
  421.     crcList(MANNEQUIN_AUTO_CRC__DECLARE_ELEMENT); \
  422.     bool m_initialised;                           \
  423.   };
  424.  
  425. #endif
  426.  
downloadICryMannequinUserParams.h 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