BVB Source Codes

CRYENGINE Show ChunkFileWriters.h Source code

Return Download CRYENGINE: download ChunkFileWriters.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name: ChunkFileWriters.h
  5. //  Created:   2013/10/21 by Sergey Sokov
  6. //
  7. ////////////////////////////////////////////////////////////////////////////
  8.  
  9. #ifndef __ChunkFileWriters_h__
  10. #define __ChunkFileWriters_h__
  11.  
  12. #include "ChunkFileComponents.h"
  13.  
  14. namespace ChunkFile
  15. {
  16.  
  17. struct IWriter
  18. {
  19.         virtual ~IWriter()
  20.         {
  21.         }
  22.  
  23.         virtual void  Erase() = 0;
  24.         virtual void  Close() = 0; // if Close() is not called then the file should be deleted in destructor
  25.  
  26.         virtual int32 GetPos() const = 0;
  27.  
  28.         virtual bool  Write(const void* buffer, size_t size) = 0;
  29.  
  30.         // non-virtual helper function
  31.         bool WriteZeros(size_t size);
  32. };
  33.  
  34. class OsFileWriter
  35.         : public IWriter
  36. {
  37. public:
  38.         OsFileWriter();
  39.         virtual ~OsFileWriter();
  40.  
  41.         bool Create(const char* filename);
  42.  
  43.         //-------------------------------------------------------
  44.         // IWriter interface
  45.         virtual void  Erase();
  46.         virtual void  Close();
  47.  
  48.         virtual int32 GetPos() const;
  49.  
  50.         virtual bool  Write(const void* buffer, size_t size);
  51.         //-------------------------------------------------------
  52.  
  53. private:
  54.         string m_filename;
  55.         FILE*  m_f;
  56.         int32  m_offset;
  57. };
  58.  
  59. #if !defined(RESOURCE_COMPILER)
  60. class CryPakFileWriter
  61.         : public IWriter
  62. {
  63. public:
  64.         CryPakFileWriter();
  65.         virtual ~CryPakFileWriter();
  66.  
  67.         bool Create(ICryPak* pPak, const char* filename);
  68.  
  69.         //-------------------------------------------------------
  70.         // IWriter interface
  71.         virtual void  Erase();
  72.         virtual void  Close();
  73.  
  74.         virtual int32 GetPos() const;
  75.  
  76.         virtual bool  Write(const void* buffer, size_t size);
  77.         //-------------------------------------------------------
  78.  
  79. private:
  80.         string   m_filename;
  81.         ICryPak* m_pPak;
  82.         FILE*    m_f;
  83.         int32    m_offset;
  84. };
  85. #endif
  86.  
  87. // Doesn't write any data, just computes the size
  88. class SizeWriter
  89.         : public IWriter
  90. {
  91. public:
  92.         SizeWriter()
  93.         {
  94.         }
  95.         virtual ~SizeWriter()
  96.         {
  97.         }
  98.  
  99.         void Start()
  100.         {
  101.                 m_offset = 0;
  102.         }
  103.  
  104.         //-------------------------------------------------------
  105.         // IWriter interface
  106.         virtual void Erase()
  107.         {
  108.         }
  109.  
  110.         virtual void Close()
  111.         {
  112.         }
  113.  
  114.         virtual int32 GetPos() const
  115.         {
  116.                 return m_offset;
  117.         }
  118.  
  119.         virtual bool Write(const void* buffer, size_t size)
  120.         {
  121.                 m_offset += size;
  122.                 return true;
  123.         }
  124.         //-------------------------------------------------------
  125.  
  126. private:
  127.         int32 m_offset;
  128. };
  129.  
  130. class MemoryWriter
  131.         : public IWriter
  132. {
  133. public:
  134.         MemoryWriter();
  135.         virtual ~MemoryWriter();
  136.  
  137.         bool Start(void* ptr, int32 size);
  138.  
  139.         //-------------------------------------------------------
  140.         // IWriter interface
  141.         virtual void  Erase();
  142.         virtual void  Close();
  143.  
  144.         virtual int32 GetPos() const;
  145.  
  146.         virtual bool  Write(const void* buffer, size_t size);
  147.         //-------------------------------------------------------
  148.  
  149. private:
  150.         char* m_ptr;
  151.         int32 m_size;
  152.         int32 m_offset;
  153. };
  154.  
  155. struct IChunkFileWriter
  156. {
  157.         virtual ~IChunkFileWriter()
  158.         {
  159.         }
  160.  
  161.         // Sets alignment for *beginning* of chunk data.
  162.         // Allowed to be called at any time, influences all future
  163.         // StartChunk() calls (until a new SetAlignment() call).
  164.         virtual void SetAlignment(size_t alignment) = 0;
  165.  
  166.         // Returns false when there is no more passes left.
  167.         virtual bool StartPass() = 0;
  168.  
  169.         // eEndianness specifies endianness of the data user is
  170.         // going to provide via AddChunkData*(). The data will be
  171.         // sent to the low-level writer as is, without any re-coding.
  172.         virtual void     StartChunk(EEndianness eEndianness, uint32 type, uint32 version, uint32 id) = 0;
  173.         virtual void     AddChunkData(void* ptr, size_t size) = 0;
  174.         virtual void     AddChunkDataZeros(size_t size) = 0;
  175.         virtual void     AddChunkDataAlignment(size_t alignment) = 0;
  176.  
  177.         virtual bool     HasWrittenSuccessfully() const = 0;
  178.  
  179.         virtual IWriter* GetWriter() const = 0;
  180. };
  181.  
  182. // Memoryless chunk file writer
  183. //
  184. // Usage example:
  185. //
  186. //      OsFileWriter writer;
  187. //      if (!writer.Create(filename))
  188. //      {
  189. //              showAnErrorMessage();
  190. //      }
  191. //      else
  192. //      {
  193. //              MemorylessChunkFileWriter wr(eChunFileFormat, writer);
  194. //              while (wr.StartPass())
  195. //              {
  196. //                      // default alignment of chunk data in file is 4, but you may change it by calling wr.SetAlignment(xxx)
  197. //
  198. //                      wr.StartChunk(eEndianness_Native, chunkA_type, chunkA_version, chunkA_id);
  199. //                      wr.AddChunkData(data_ptr0, data_size0);  // make sure that data have endianness specified by bLittleEdndian
  200. //                      wr.AddChunkData(data_ptr1, data_size1);
  201. //                      ...
  202. //                      wr.StartChunk(eEndianness_Native, chunkB_type, chunkB_version, chunkB_id);
  203. //                      wr.AddChunkData(data_ptrN, data_sizeN);
  204. //                      ...
  205. //              }
  206. //              if (!wr.HasWrittenSuccessfully())
  207. //              {
  208. //                      showAnErrorMessage();
  209. //              }
  210. //      }
  211.  
  212. class MemorylessChunkFileWriter
  213.         : public IChunkFileWriter
  214. {
  215. public:
  216.         enum EChunkFileFormat
  217.         {
  218.                 eChunkFileFormat_0x745,
  219.                 eChunkFileFormat_0x746,
  220.         };
  221.  
  222.         MemorylessChunkFileWriter(EChunkFileFormat eFormat, IWriter* pWriter);
  223.  
  224.         //-------------------------------------------------------
  225.         // IChunkFileWriter interface
  226.         virtual ~MemorylessChunkFileWriter();
  227.  
  228.         virtual void     SetAlignment(size_t alignment);
  229.  
  230.         virtual bool     StartPass();
  231.  
  232.         virtual void     StartChunk(EEndianness eEndianness, uint32 type, uint32 version, uint32 id);
  233.         virtual void     AddChunkData(void* ptr, size_t size);
  234.         virtual void     AddChunkDataZeros(size_t size);
  235.         virtual void     AddChunkDataAlignment(size_t alignment);
  236.  
  237.         virtual bool     HasWrittenSuccessfully() const;
  238.  
  239.         virtual IWriter* GetWriter() const;
  240.         //-------------------------------------------------------
  241.  
  242. private:
  243.         void          Fail();
  244.  
  245.         static size_t ComputeSizeOfAlignmentArea(size_t pos, size_t alignment);
  246.  
  247.         size_t        GetSizeOfHeader() const;
  248.         void          WriteFileHeader(int32 chunkCount, uint32 chunkTableOffsetInFile);
  249.  
  250.         size_t        GetSizeOfChunkTable(int32 chunkCount) const;
  251.         void          WriteChunkTableHeader(int32 chunkCount);
  252.         void          WriteChunkEntry();
  253.  
  254. private:
  255.         IWriter* const   m_pWriter;
  256.  
  257.         EChunkFileFormat m_eChunkFileFormat;
  258.  
  259.         size_t           m_alignment;
  260.  
  261.         int32            m_chunkCount;
  262.  
  263.         int32            m_chunkIndex;
  264.         uint16           m_chunkType;
  265.         uint16           m_chunkVersion;
  266.         uint32           m_chunkId;
  267.         uint32           m_chunkSize;
  268.         uint32           m_chunkOffsetInFile;
  269.         EEndianness      m_chunkEndianness;
  270.  
  271.         uint32           m_dataOffsetInFile;
  272.  
  273.         enum EState
  274.         {
  275.                 eState_Init,
  276.  
  277.                 eState_CountingChunks,
  278.                 eState_WritingChunkTable,
  279.                 eState_WritingData,
  280.  
  281.                 eState_Success,
  282.                 eState_Fail,
  283.         };
  284.         EState m_eState;
  285. };
  286.  
  287. }  // namespace ChunkFile
  288.  
  289. #endif
  290.  
downloadChunkFileWriters.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