BVB Source Codes

CRYENGINE Show ChunkFileComponents.h Source code

Return Download CRYENGINE: download ChunkFileComponents.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __ChunkFileComponents_h__
  4. #define __ChunkFileComponents_h__
  5.  
  6. #include <Cry3DEngine/CGF/CryHeaders.h>
  7.  
  8. namespace ChunkFile
  9. {
  10.  
  11. // All chunk files use *little-endian* format to store file header and chunk.
  12. // Chunk data are stored in either little-endian or big-endian format,
  13. // see kBigEndianVersionFlag.
  14.  
  15. struct FileHeader_0x744_0x745
  16. {
  17.         char   signature[7];
  18.         char   _pad_[1];
  19.         uint32 fileType;
  20.         uint32 version;
  21.         uint32 chunkTableOffset;
  22.  
  23.         enum EFileType
  24.         {
  25.                 eFileType_Geom = 0xFFFF0000U,
  26.                 eFileType_Anim,
  27.         };
  28.  
  29.         static const char* GetExpectedSignature()
  30.         {
  31.                 return "CryTek";
  32.         }
  33.  
  34.         bool HasValidSignature() const
  35.         {
  36.                 return memcmp(GetExpectedSignature(), signature, sizeof(signature)) == 0;
  37.         }
  38.  
  39.         void Set(uint32 a_chunkTableOffset)
  40.         {
  41.                 memcpy(signature, GetExpectedSignature(), sizeof(signature));
  42.                 _pad_[0] = 0;
  43.                 // We need to set eFileType_Geom or eFileType_Anim, but asking
  44.                 // the caller to provide us the type will complicate the code, so we
  45.                 // set eFileType_Geom only. It's ok because all our readers
  46.                 // don't differentiate between eFileType_Geom and eFileType_Anim.
  47.                 fileType = eFileType_Geom;
  48.                 version = 0x745;
  49.                 chunkTableOffset = a_chunkTableOffset;
  50.         }
  51.  
  52.         void SwapEndianness()
  53.         {
  54.                 SwapEndianBase(&fileType, 1);
  55.                 SwapEndianBase(&version, 1);
  56.                 SwapEndianBase(&chunkTableOffset, 1);
  57.         }
  58. };
  59.  
  60. struct FileHeader_0x746
  61. {
  62.         char               signature[4];
  63.         uint32             version;
  64.         uint32             chunkCount;
  65.         uint32             chunkTableOffset;
  66.  
  67.         static const char* GetExpectedSignature()
  68.         {
  69.                 return "CrCh";
  70.         }
  71.  
  72.         bool HasValidSignature() const
  73.         {
  74.                 return memcmp(GetExpectedSignature(), signature, sizeof(signature)) == 0;
  75.         }
  76.  
  77.         void Set(int32 a_chunkCount, uint32 a_chunkTableOffset)
  78.         {
  79.                 memcpy(signature, GetExpectedSignature(), sizeof(signature));
  80.                 version = 0x746;
  81.                 chunkCount = a_chunkCount;
  82.                 chunkTableOffset = a_chunkTableOffset;
  83.         }
  84.  
  85.         void SwapEndianness()
  86.         {
  87.                 SwapEndianBase(&version, 1);
  88.                 SwapEndianBase(&chunkCount, 1);
  89.                 SwapEndianBase(&chunkTableOffset, 1);
  90.         }
  91. };
  92.  
  93. struct ChunkHeader_0x744_0x745
  94. {
  95.         uint32 type;
  96.         uint32 version;
  97.         uint32 offsetInFile;
  98.         uint32 id;
  99.  
  100.         enum { kBigEndianVersionFlag = 0x80000000U };
  101.  
  102.         void SwapEndianness()
  103.         {
  104.                 SwapEndianBase(&type, 1);
  105.                 SwapEndianBase(&version, 1);
  106.                 SwapEndianBase(&offsetInFile, 1);
  107.                 SwapEndianBase(&id, 1);
  108.         }
  109. };
  110.  
  111. struct ChunkTableEntry_0x744
  112.         : public ChunkHeader_0x744_0x745
  113. {
  114.         void SwapEndianness()
  115.         {
  116.                 ChunkHeader_0x744_0x745::SwapEndianness();
  117.         }
  118. };
  119.  
  120. struct ChunkTableEntry_0x745
  121.         : public ChunkHeader_0x744_0x745
  122. {
  123.         uint32 size;
  124.  
  125.         void SwapEndianness()
  126.         {
  127.                 ChunkHeader_0x744_0x745::SwapEndianness();
  128.                 SwapEndianBase(&size, 1);
  129.         }
  130. };
  131.  
  132. struct ChunkTableEntry_0x746
  133. {
  134.         uint16 type;
  135.         uint16 version;
  136.         uint32 id;
  137.         uint32 size;
  138.         uint32 offsetInFile;
  139.  
  140.         enum { kBigEndianVersionFlag = 0x8000U };
  141.  
  142.         void SwapEndianness()
  143.         {
  144.                 SwapEndianBase(&type, 1);
  145.                 SwapEndianBase(&version, 1);
  146.                 SwapEndianBase(&id, 1);
  147.                 SwapEndianBase(&size, 1);
  148.                 SwapEndianBase(&offsetInFile, 1);
  149.         }
  150. };
  151.  
  152. // We need this function to strip 0x744 & 0x745 chunk headers
  153. // from chunk data properly: some chunks in 0x744 and 0x745 formats
  154. // don't have chunk headers in their data.
  155. // 'chunkType' is expected to be provided in the 0x746 format.
  156. inline bool ChunkContainsHeader_0x744_0x745(const uint16 chunkType, const uint16 chunkVersion)
  157. {
  158.         switch (chunkType)
  159.         {
  160.         case ChunkType_SourceInfo:
  161.                 return false;
  162.         case ChunkType_Controller:
  163.                 return (chunkVersion != CONTROLLER_CHUNK_DESC_0827::VERSION);
  164.         case ChunkType_BoneNameList:
  165.                 return (chunkVersion != BONENAMELIST_CHUNK_DESC_0745::VERSION);
  166.         case ChunkType_MeshMorphTarget:
  167.                 return (chunkVersion != MESHMORPHTARGET_CHUNK_DESC_0001::VERSION);
  168.         case ChunkType_BoneInitialPos:
  169.                 return (chunkVersion != BONEINITIALPOS_CHUNK_DESC_0001::VERSION);
  170.         default:
  171.                 return true;
  172.         }
  173. }
  174.  
  175. static inline uint16 ConvertChunkTypeTo0x746(uint32 type)
  176. {
  177.         if (type <= 0xFFFF)
  178.         {
  179.                 // Input type seems to be already in 0x746 format (or it's 0)
  180.                 return type;
  181.         }
  182.  
  183.         // Input type seems to be in 0x745 format
  184.  
  185.         if ((type & 0xFFFF) >= 0xF000)
  186.         {
  187.                 // Cannot fit into resulting 0x746 type (uint16)
  188.                 return 0;
  189.         }
  190.         if ((type & 0xFFFF0000U) == 0xCCCC0000U)
  191.         {
  192.                 return 0x1000 + (type & 0x0FFF);
  193.         }
  194.         if ((type & 0xFFFF0000U) == 0xACDC0000U)
  195.         {
  196.                 return 0x2000 + (type & 0x0FFF);
  197.         }
  198.         if ((type & 0xFFFF0000U) == 0xAAFC0000U)
  199.         {
  200.                 return 0x3000 + (type & 0x0FFF);
  201.         }
  202.  
  203.         // Unknown 0x745 chunk type
  204.         return 0;
  205. }
  206.  
  207. static inline uint32 ConvertChunkTypeTo0x745(uint32 type)
  208. {
  209.         if (type > 0xFFFF)
  210.         {
  211.                 // Input type seems to be already in 0x745 format
  212.                 return type;
  213.         }
  214.  
  215.         // Input type seems to be in 0x746 format
  216.  
  217.         if ((type & 0xF000) == 0x1000)
  218.         {
  219.                 return 0xCCCC0000U + (type & 0x0FFF);
  220.         }
  221.         if ((type & 0xF000) == 0x2000)
  222.         {
  223.                 return 0xACDC0000U + (type & 0x0FFF);
  224.         }
  225.         if ((type & 0xF000) == 0x3000)
  226.         {
  227.                 return 0xAAFC0000U + (type & 0x0FFF);
  228.         }
  229.  
  230.         // Unknown 0x746 chunk type (or it's 0)
  231.         return 0;
  232. }
  233.  
  234. } // namespace ChunkFile
  235.  
  236. #endif
  237.  
downloadChunkFileComponents.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