BVB Source Codes

CRYENGINE Show ICryMannequinDefs.h Source code

Return Download CRYENGINE: download ICryMannequinDefs.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. ////////////////////////////////////////////////////////////////////////////
  5. #ifndef __I_CRY_MANNEQUINDEFS_H__
  6. #define __I_CRY_MANNEQUINDEFS_H__
  7.  
  8. #define STORE_TAG_STRINGS 1 //TODO: !_RELEASE
  9.  
  10. // Set this to 0 to remove animation name strings. This saves about 15% of memory per ADB, but makes debugging very hard
  11. #define STORE_ANIMNAME_STRINGS 1
  12.  
  13. #if defined(_RELEASE)
  14.         #define STORE_PROCCLIP_STRINGS 0
  15.         #define STORE_SCOPE_STRINGS    0
  16. #else
  17.         #define STORE_PROCCLIP_STRINGS 1
  18.         #define STORE_SCOPE_STRINGS    1
  19. #endif
  20.  
  21. typedef int32 TagID; // should be uint32, but it's too scary because we regularly check (tagID >= 0) instead of (tagID != TAG_ID_INVALID)
  22. static const TagID TAG_ID_INVALID = ~TagID(0);
  23.  
  24. typedef int32 TagGroupID; // should be uint32, but it's too scary because we regularly check (tagGroupID >= 0) instead of (tagGroupID != TAG_ID_INVALID)
  25. static const TagGroupID GROUP_ID_NONE = ~TagGroupID(0);
  26.  
  27. typedef TagID FragmentID; // should be uint32, but it's too scary because we regularly check (fragmentID >= 0) instead of (fragmentID != TAG_ID_INVALID)
  28. static const FragmentID FRAGMENT_ID_INVALID = TAG_ID_INVALID;
  29.  
  30. static const TagID SCOPE_ID_INVALID = TAG_ID_INVALID;
  31.  
  32. typedef uint32 AnimCRC; // CRC of the name of the animation
  33. static const AnimCRC ANIM_CRC_INVALID = AnimCRC(0);
  34.  
  35. static const uint32 OPTION_IDX_RANDOM = 0xfffffffe;
  36. static const uint32 OPTION_IDX_INVALID = 0xffffffff;
  37.  
  38. static const uint32 TAG_SET_IDX_INVALID = ~uint32(0);
  39.  
  40. typedef uint64 ActionScopes;
  41. static const ActionScopes ACTION_SCOPES_ALL = ~ActionScopes(0);
  42. static const ActionScopes ACTION_SCOPES_NONE = ActionScopes(0);
  43.  
  44. //suggestion: typedef uint32 ScopeContextId;
  45. static const TagID SCOPE_CONTEXT_ID_INVALID = TAG_ID_INVALID;
  46.  
  47. struct SCRCRefHash_CRC32Lowercase
  48. {
  49.         typedef uint32 TInt;
  50.         static const TInt INVALID = 0;
  51.  
  52.         static TInt       CalculateHash(const char* const s)
  53.         {
  54.                 assert(s);
  55.                 assert(s[0]);
  56.  
  57.                 const TInt crc = CCrc32::ComputeLowercase(s);
  58.                 if (crc == INVALID)
  59.                 {
  60.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Congratulations, you hit the jackpot! The string '%s' has a lowercase CRC32 equal to %u. Unfortunately this number is reserved for errors, so please rename and try again...", s, INVALID);
  61.                 }
  62.                 return crc;
  63.         }
  64. };
  65.  
  66. struct SCRCRefHash_CRC32
  67. {
  68.         typedef uint32 TInt;
  69.         static const TInt INVALID = 0;
  70.  
  71.         static TInt       CalculateHash(const char* const s)
  72.         {
  73.                 assert(s);
  74.                 assert(s[0]);
  75.  
  76.                 const TInt crc = CCrc32::Compute(s);
  77.                 if (crc == INVALID)
  78.                 {
  79.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Congratulations, you hit the jackpot! The string '%s' has a CRC32 equal to %u. Unfortunately this number is reserved for errors, so please rename and try again...", s, INVALID);
  80.                 }
  81.                 return crc;
  82.         }
  83. };
  84.  
  85. template<uint32 StoreStrings, typename THash = SCRCRefHash_CRC32Lowercase>
  86. struct SCRCRef
  87. {
  88. };
  89.  
  90. template<typename THash>
  91. struct SCRCRef<0, THash>
  92. {
  93.         typedef typename THash::TInt TInt;
  94.         static const TInt INVALID = THash::INVALID;
  95.  
  96.         SCRCRef()
  97.                 : crc(INVALID)
  98.         {
  99.         }
  100.  
  101.         explicit SCRCRef(const char* const nameString)
  102.         {
  103.                 SetByString(nameString);
  104.         }
  105.  
  106.         void SetByString(const char* const nameString)
  107.         {
  108.                 if (nameString && (nameString[0] != '\0'))
  109.                 {
  110.                         crc = THash::CalculateHash(nameString);
  111.                 }
  112.                 else
  113.                 {
  114.                         crc = INVALID;
  115.                 }
  116.         }
  117.  
  118.         ILINE bool IsEmpty() const
  119.         {
  120.                 return (crc == INVALID);
  121.         }
  122.  
  123.         ILINE const char* c_str() const
  124.         {
  125.                 if (crc == INVALID)
  126.                 {
  127.                         return "";
  128.                 }
  129.                 return "STRIPPED_CRC_NAMES";
  130.         }
  131.  
  132.         ILINE SCRCRef<0>& operator=(const char* const s)
  133.         {
  134.                 SetByString(s);
  135.                 return *this;
  136.         }
  137.  
  138.         template<uint32 StoreStringsRhs>
  139.         ILINE bool operator==(const SCRCRef<StoreStringsRhs, THash>& rhs) const
  140.         {
  141.                 return (crc == rhs.crc);
  142.         }
  143.  
  144.         template<uint32 StoreStringsRhs>
  145.         ILINE bool operator!=(const SCRCRef<StoreStringsRhs, THash>& rhs) const
  146.         {
  147.                 return (crc != rhs.crc);
  148.         }
  149.  
  150.         template<uint32 StoreStringsRhs>
  151.         ILINE bool operator<(const SCRCRef<StoreStringsRhs, THash>& rhs) const
  152.         {
  153.                 return (crc < rhs.crc);
  154.         }
  155.  
  156.         ILINE uint32 ToUInt32() const
  157.         {
  158.                 return static_cast<uint32>(crc);
  159.         }
  160.  
  161.         TInt crc;
  162. };
  163.  
  164. template<typename THash>
  165. struct SCRCRef<1, THash>
  166. {
  167.         typedef typename THash::TInt TInt;
  168.         static const TInt INVALID = THash::INVALID;
  169.  
  170.         SCRCRef()
  171.                 : crc(INVALID)
  172.                 , stringValue()
  173.         {
  174.         }
  175.  
  176.         explicit SCRCRef(const char* const nameString)
  177.                 : crc(INVALID)
  178.                 , stringValue()
  179.         {
  180.                 SetByString(nameString);
  181.         }
  182.  
  183.         SCRCRef(const SCRCRef<1>& other)
  184.                 : crc(INVALID)
  185.                 , stringValue()
  186.         {
  187.                 SetByString(other.c_str());
  188.         }
  189.  
  190.         SCRCRef<1>& operator=(const SCRCRef<1>& other)
  191.         {
  192.                 if (&other != this)
  193.                 {
  194.                         SetByString(other.c_str());
  195.                 }
  196.                 return *this;
  197.         }
  198.  
  199.         void SetByString(const char* const nameString)
  200.         {
  201.                 if (nameString && (nameString[0] != '\0'))
  202.                 {
  203.                         const size_t lengthPlusOne = strlen(nameString) + 1;
  204.                         stringValue.assign(nameString, nameString + lengthPlusOne);
  205.  
  206.                         crc = THash::CalculateHash(nameString);
  207.                 }
  208.                 else
  209.                 {
  210.                         stringValue.clear();
  211.                         crc = INVALID;
  212.                 }
  213.         }
  214.  
  215.         ILINE bool IsEmpty() const
  216.         {
  217.                 return (crc == INVALID);
  218.         }
  219.  
  220.         ILINE const char* c_str() const
  221.         {
  222.                 return stringValue.empty() ? "" : stringValue.data();
  223.         }
  224.  
  225.         ILINE SCRCRef<1>& operator=(const char* const s)
  226.         {
  227.                 SetByString(s);
  228.                 return *this;
  229.         }
  230.  
  231.         template<uint32 StoreStringsRhs>
  232.         ILINE bool operator==(const SCRCRef<StoreStringsRhs, THash>& rhs) const
  233.         {
  234.                 return (crc == rhs.crc);
  235.         }
  236.  
  237.         template<uint32 StoreStringsRhs>
  238.         ILINE bool operator!=(const SCRCRef<StoreStringsRhs, THash>& rhs) const
  239.         {
  240.                 return (crc != rhs.crc);
  241.         }
  242.  
  243.         template<uint32 StoreStringsRhs>
  244.         ILINE bool operator<(const SCRCRef<StoreStringsRhs, THash>& rhs) const
  245.         {
  246.                 return (crc < rhs.crc);
  247.         }
  248.  
  249.         ILINE uint32 ToUInt32() const
  250.         {
  251.                 return static_cast<uint32>(crc);
  252.         }
  253.  
  254.         TInt crc;
  255.  
  256. private:
  257.         DynArray<char> stringValue;
  258. };
  259.  
  260. typedef SCRCRef<STORE_TAG_STRINGS>      STagRef;
  261. typedef SCRCRef<STORE_ANIMNAME_STRINGS> SAnimRef;
  262. typedef SCRCRef<STORE_SCOPE_STRINGS>    SScopeRef;
  263.  
  264. const uint32 DEF_PATH_LENGTH = 512;
  265. typedef SCRCRef<1>                      TDefPathString;
  266.  
  267. typedef SCRCRef<STORE_PROCCLIP_STRINGS> SProcDataCRC;
  268.  
  269. typedef SCRCRef<1>                      TProcClipTypeName;
  270.  
  271. typedef CCryName                        TProcClipString;
  272.  
  273. enum eSequenceFlags
  274. {
  275.         eSF_Fragment        = BIT(0),
  276.         eSF_TransitionOutro = BIT(1),
  277.         eSF_Transition      = BIT(2)
  278. };
  279.  
  280. struct SWeightData
  281. {
  282.         enum { MAX_WEIGHTS = 4 };
  283.  
  284.         SWeightData() { memset(&weights, 0, MAX_WEIGHTS * sizeof(weights[0])); }
  285.  
  286.         float weights[MAX_WEIGHTS];
  287. };
  288.  
  289. #endif //__I_CRY_MANNEQUINDEFS_H__
  290.  
downloadICryMannequinDefs.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