563 lines
19 KiB
C++
563 lines
19 KiB
C++
#pragma once
|
|
|
|
#include "../VTAll.hpp"
|
|
#include <memory>
|
|
#include <functional>
|
|
|
|
namespace LibCmo::CK2 {
|
|
|
|
class CKStateChunk {
|
|
public:
|
|
CKStateChunk(CKFileVisitor* visitor, CKContext* ctx);
|
|
CKStateChunk(const CKStateChunk&);
|
|
CKStateChunk(CKStateChunk&&);
|
|
CKStateChunk& operator=(const CKStateChunk&);
|
|
CKStateChunk& operator=(CKStateChunk&&);
|
|
~CKStateChunk();
|
|
|
|
#pragma region Self Used Data Struct
|
|
|
|
public:
|
|
struct ProfileStateChunk_t {
|
|
CK_CLASSID m_ClassId;
|
|
CKDWORD m_DataDwSize;
|
|
CKDWORD* m_pData;
|
|
|
|
CK_STATECHUNK_DATAVERSION m_DataVersion;
|
|
CK_STATECHUNK_CHUNKVERSION m_ChunkVersion;
|
|
|
|
size_t m_ObjectListSize, m_ChunkListSize, m_ManagerListSize;
|
|
|
|
CKFileVisitor* m_BindFile;
|
|
CKContext* m_BindContext;
|
|
};
|
|
struct ProfileIdentifier_t {
|
|
CKDWORD m_Identifier;
|
|
void* m_DataPtr;
|
|
CKDWORD m_AreaSize;
|
|
};
|
|
|
|
class LockedReadBufferDeleter {
|
|
public:
|
|
LockedReadBufferDeleter() : m_Host(nullptr), m_ConsumedSize(0) {}
|
|
LockedReadBufferDeleter(CKStateChunk* host, CKDWORD init_size) :
|
|
m_Host(host), m_ConsumedSize(init_size) {}
|
|
LIBCMO_DEFAULT_COPY_MOVE(LockedReadBufferDeleter);
|
|
|
|
void operator()(LIBCMO_UNUSED const void* buf);
|
|
void SetConsumedSize(CKDWORD newsize);
|
|
private:
|
|
CKStateChunk* m_Host;
|
|
CKDWORD m_ConsumedSize;
|
|
};
|
|
|
|
class LockedWriteBufferDeleter {
|
|
public:
|
|
LockedWriteBufferDeleter() : m_Host(nullptr), m_ConsumedSize(0) {}
|
|
LockedWriteBufferDeleter(CKStateChunk* host, CKDWORD init_size) :
|
|
m_Host(host), m_ConsumedSize(init_size) {}
|
|
LIBCMO_DEFAULT_COPY_MOVE(LockedWriteBufferDeleter);
|
|
|
|
void operator()(LIBCMO_UNUSED const void* buf);
|
|
void SetConsumedSize(CKDWORD newsize);
|
|
private:
|
|
CKStateChunk* m_Host;
|
|
CKDWORD m_ConsumedSize;
|
|
};
|
|
|
|
class BufferDeleter {
|
|
public:
|
|
BufferDeleter() : m_Host(nullptr), m_BufSize(0) {}
|
|
BufferDeleter(CKStateChunk* host, CKDWORD bufsize) :
|
|
m_Host(host), m_BufSize(bufsize) {}
|
|
LIBCMO_DEFAULT_COPY_MOVE(BufferDeleter);
|
|
|
|
void operator()(const void* buf);
|
|
CKDWORD GetBufferSize() const;
|
|
private:
|
|
CKStateChunk* m_Host;
|
|
CKDWORD m_BufSize;
|
|
};
|
|
|
|
using LockedReadBuffer_t = std::unique_ptr<const void, LockedReadBufferDeleter>;
|
|
using LockedWriteBuffer_t = std::unique_ptr<void, LockedWriteBufferDeleter>;
|
|
using Buffer_t = std::unique_ptr<void, BufferDeleter>;
|
|
|
|
private:
|
|
enum class CKStateChunkStatus : CKDWORD {
|
|
IDLE,
|
|
READ,
|
|
WRITE
|
|
};
|
|
struct ChunkParser {
|
|
CKStateChunkStatus m_Status;
|
|
CKDWORD m_CurrentPos;
|
|
CKDWORD m_DataSize;
|
|
CKDWORD m_PrevIdentifierPos;
|
|
};
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Member Decl
|
|
|
|
CK_CLASSID m_ClassId;
|
|
CKDWORD m_DataDwSize;
|
|
CKDWORD* m_pData;
|
|
|
|
CK_STATECHUNK_DATAVERSION m_DataVersion;
|
|
CK_STATECHUNK_CHUNKVERSION m_ChunkVersion;
|
|
|
|
ChunkParser m_Parser;
|
|
|
|
XContainer::XArray<CKDWORD> m_ObjectList;
|
|
XContainer::XArray<CKDWORD> m_ChunkList;
|
|
XContainer::XArray<CKDWORD> m_ManagerList;
|
|
|
|
CKFileVisitor* m_BindFile;
|
|
CKContext* m_BindContext;
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Buffer Related
|
|
|
|
public:
|
|
bool ConvertFromBuffer(const void* buf);
|
|
CKDWORD ConvertToBuffer(void* buf);
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Misc Functions
|
|
|
|
public:
|
|
// ===== 2 Profiles Getter used by Unvirt =====
|
|
|
|
/**
|
|
* @brief Get basic info of this CKStateChunk.
|
|
* @return The struct describing this CKStateChunk.
|
|
*/
|
|
const ProfileStateChunk_t GetStateChunkProfile();
|
|
/**
|
|
* @brief Get all indentifier infos of this CKStateChunk,
|
|
* including identifier self, data area size and address.
|
|
* @return A arrary, each item describe a single identifier's info.
|
|
* @remark The detail of implement can be seen in SeekIdentifierAndReturnSize()
|
|
* @see SeekIdentifierAndReturnSize
|
|
*/
|
|
const XContainer::XArray<ProfileIdentifier_t> GetIdentifiersProfile();
|
|
|
|
/**
|
|
* @brief Clear this CKStateChunk, restore it to original status for other using.
|
|
*/
|
|
void Clear();
|
|
/**
|
|
* @brief Get the size of data buffer in this CKStateChunk.
|
|
* @return The data buffer's size in CKBYTE.
|
|
*/
|
|
CKDWORD GetDataSize() const;
|
|
/**
|
|
* @brief Get data version in this CKStateChunk.
|
|
* @remark Data version is frequently used by calling of CKStateChunk to distinguish different data layout due to compatibility reason.
|
|
* @return The data version.
|
|
*/
|
|
CK_STATECHUNK_DATAVERSION GetDataVersion() const;
|
|
/**
|
|
* @brief Set data version of this CKStateChunk.
|
|
* @param version The set data version
|
|
* @remark Frequently used when saving someing in CKStateChunk.
|
|
*/
|
|
void SetDataVersion(CK_STATECHUNK_DATAVERSION version);
|
|
/**
|
|
* @brief Get associated CK_CLASSID of this CKStateChunk
|
|
* @return Associated CK_CLASSID
|
|
*/
|
|
CK_CLASSID GetClassId() const;
|
|
/**
|
|
* @brief Set associated CK_CLASSID of this CKStateChunk.
|
|
* @param cid The set CK_CLASSID
|
|
* @remark Frequently used at the end of CKObject::Save() override.
|
|
*/
|
|
void SetClassId(CK_CLASSID cid);
|
|
|
|
|
|
bool Skip(CKDWORD DwordCount);
|
|
|
|
private:
|
|
/**
|
|
* @brief Convert byte based size to DWORD based size.
|
|
*
|
|
* Becase CKStateChunk use DWORD based buffer, so all data should be aligned to DWORD boundary.
|
|
* This function can convert byte based size to DWORD based size while keeping its size aligned with DWORD boundary.
|
|
* For example, caller want to allocate 3 bytes for data storing, this function will first align it to DWORD boundary, 4 bytes.
|
|
* Then convert it in DWORD size, 1 DWORD.
|
|
*
|
|
* @param char_size[in] The size in byte unit.
|
|
* @return The size in DWORD unit.
|
|
*/
|
|
CKDWORD GetCeilDwordSize(size_t char_size);
|
|
bool ResizeBuffer(CKDWORD new_dwsize);
|
|
/**
|
|
* @brief Check whether there are enough buffer to read.
|
|
*
|
|
* This function will check whether current CKStateChunk is in read mode and
|
|
* whether data area is enough to write.
|
|
* However, it is different with EnsureReadSpace. If no space to write, this function will
|
|
* try calling ResizeBuffer to get a enough buffer. Only when resize failed,
|
|
* this function will return false.
|
|
*
|
|
* @param dwsize[in] Required buffer size in DWORD unit.
|
|
* @return True if have enough space to write.
|
|
* @see EnsureReadSpace
|
|
*/
|
|
bool EnsureWriteSpace(CKDWORD dwsize);
|
|
/**
|
|
* @brief Check whether there are enough buffer to read.
|
|
*
|
|
* This function will check whether current CKStateChunk is in read mode and
|
|
* whether data area is enough to read.
|
|
*
|
|
* @param dword_required[in] Required buffer size in DWORD unit.
|
|
* @return True if have enough space to read.
|
|
* @see EnsureWriteSpace
|
|
*/
|
|
bool EnsureReadSpace(CKDWORD dword_required);
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Read Function
|
|
|
|
public:
|
|
void StartRead(void);
|
|
void StopRead(void);
|
|
|
|
/* ========== Identifier Functions ==========*/
|
|
|
|
bool SeekIdentifierDword(CKDWORD identifier);
|
|
bool SeekIdentifierDwordAndReturnSize(CKDWORD identifier, CKDWORD* out_size);
|
|
template<typename TEnum>
|
|
inline bool SeekIdentifier(TEnum enum_v) {
|
|
return SeekIdentifierDword(static_cast<CKDWORD>(enum_v));
|
|
}
|
|
template<typename TEnum>
|
|
inline bool SeekIdentifierAndReturnSize(TEnum enum_v, CKDWORD* out_size) {
|
|
return SeekIdentifierDwordAndReturnSize(static_cast<CKDWORD>(enum_v), out_size);
|
|
}
|
|
|
|
/* ========== Read Buffer Controller ==========*/
|
|
|
|
public:
|
|
/**
|
|
* @brief Lock read buffer and make sure it has at least some bytes to read.
|
|
* @param ppData[out] The pointer to pointer receiving data address.
|
|
* @param size_in_byte[in] The number of bytes present in the read buffer needs to be ensured.
|
|
* @return Treu if success (can read)
|
|
* @remark
|
|
* + It actually not lock the buffer, just make sure that the read area is okey.
|
|
* + Do not forget calling UnLockReadBuffer after all read work done.
|
|
* @see UnLockReadBuffer, ReadBufferLocker
|
|
*/
|
|
bool LockReadBuffer(const void** ppData, CKDWORD size_in_byte);
|
|
/**
|
|
* @brief Unlock read buffer and move forward with specified bytes.
|
|
* @param size_in_byte[in] The number of bytes you wish to move forward.
|
|
* This value can be different with the value passed to LockReadBuffer but should not greater than it.
|
|
* @return True if success (have enough space to move forward)
|
|
* @remark
|
|
* + It actually not unlock the buffer, just move forward reading pointer.
|
|
* + Used together with LockReadBuffer.
|
|
* @see LockReadBuffer
|
|
*/
|
|
bool UnLockReadBuffer(CKDWORD size_in_byte);
|
|
/**
|
|
* @brief A RAII wrapper for LockReadBuffer and UnLockReadBuffer.
|
|
* @param size_in_byte[in] The value passed to LockReadBuffer.
|
|
* @return LockedReadBuffer_t (actually is a std::unique_ptr with custom deleter)
|
|
* @remark
|
|
* + The return value is just a std::unique_ptr but its deleter have more features.
|
|
* + If return value contained data is nullptr, it mean that this function is failed.
|
|
* + If you only use the pointer provided by the return value, the final moving forward byte count is the value passed in this function.
|
|
* + You also can use LockedReadBuffer_t.get_deleter().SetConsumedSize() to set the final moving forward byte count before the return value free itself.
|
|
* + The value passed to LockedReadBuffer_t..get_deleter().SetConsumedSize() will finally be passed to UnLockReadBuffer.
|
|
* + You can use LockedReadBuffer_t.reset() to force free the return value.
|
|
* @remark Here is a example.
|
|
* ```
|
|
* auto buf = chunk->LockReadBufferWrapper(1919810);
|
|
* if (buf) {
|
|
* stuff(buf.get()); // do some operation...
|
|
* buf.get_deleter().SetConsumedSize(114514); // i only consume these bytes.
|
|
* buf.reset(); // immediately free it.
|
|
* }
|
|
* ```
|
|
* @see LockReadBuffer, UnLockReadBuffer, LockedReadBuffer_t
|
|
*/
|
|
LockedReadBuffer_t LockReadBufferWrapper(CKDWORD size_in_byte);
|
|
|
|
/* ========== Basic Data Read Functions ==========*/
|
|
|
|
private:
|
|
/**
|
|
* @brief A struct-read-friendly wrapper for LockReadBuffer and UnLockReadBuffer.
|
|
* All following struct reading function use this function as a underlaying calling.
|
|
* @param data_ptr[out] the pointer to data. must be allocated first.
|
|
* @param size_in_byte[in] the size of data in byte.
|
|
* @return True if success.
|
|
*/
|
|
bool ReadByteData(void* data_ptr, CKDWORD size_in_byte);
|
|
public:
|
|
/**
|
|
* @brief Read Struct
|
|
* @tparam T The reading type.
|
|
* @param data Data pointer for reading. Can not be bullptr
|
|
* @return True if reading success.
|
|
* @remark
|
|
* + This function is a reinterpter of a bunch of original Virtools SDK reading functions, including:
|
|
* - Primitive type: ReadInt, ReadByte, ReadWord, ReadDword, ReadFloat, etc...
|
|
* - Struct type: ReadGuid, ReadVector, ReadMatrix, etc...
|
|
* @see ReadStruct(T&)
|
|
*/
|
|
template<typename T>
|
|
bool ReadStruct(T* data) {
|
|
return ReadByteData(data, CKSizeof(T));
|
|
}
|
|
/**
|
|
* @brief Read Struct (Reference Type)
|
|
* @tparam T The reading type.
|
|
* @param data Data reference for reading.
|
|
* @return True if reading success.
|
|
* @see ReadStruct(T*)
|
|
*/
|
|
template<typename T>
|
|
inline bool ReadStruct(T& data) {
|
|
return ReadByteData(&data, CKSizeof(T));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read string. The content of string will automatically converted into UTF8 format.
|
|
/// </summary>
|
|
/// <param name="strl"></param>
|
|
/// <returns></returns>
|
|
bool ReadString(XContainer::XString* strl);
|
|
inline bool ReadString(XContainer::XString& strl) {
|
|
return ReadString(&strl);
|
|
}
|
|
|
|
/* ========== Complex Data Read Functions ==========*/
|
|
|
|
bool ReadObjectID(CK_ID* id);
|
|
bool ReadObjectPointer(ObjImpls::CKObject** obj);
|
|
inline bool ReadObjectID(CK_ID& id) {
|
|
return ReadObjectID(&id);
|
|
}
|
|
inline bool ReadObjectPointer(ObjImpls::CKObject*& id) {
|
|
return ReadObjectPointer(&id);
|
|
}
|
|
|
|
bool ReadManagerInt(CKGUID* guid, CKINT* intval);
|
|
inline bool ReadManagerInt(CKGUID& guid, CKINT& intval) {
|
|
return ReadManagerInt(&guid, &intval);
|
|
}
|
|
|
|
/**
|
|
* @brief Read sub chunk
|
|
* @return Returned a new created of CKStateChunk if success, otherwise nullptr.
|
|
* Returned CKStateChunk should be manually released!
|
|
*/
|
|
CKStateChunk* ReadSubChunk();
|
|
|
|
/* ========== Buffer Functions ==========*/
|
|
|
|
/*
|
|
Buffer related function implements:
|
|
|
|
ReadBuffer(void**) Read Byte based size. -> ReadAndCopyBuffer(void**, CKDWORD*)
|
|
ReadAndFillBuffer(int, void*) User give Byte based size. -> ReadBuffer(const void**, CKDWORD)
|
|
ReadAndFillBuffer(void*) Read Byte based size. -> ReadBuffer(const void**, CKDWORD*)
|
|
ReadAndFillBuffer_LEndian(int, void*) User give Byte based size. -> ReadBuffer(const void**, CKDWORD)
|
|
ReadAndFillBuffer_LEndian(void*) Read Byte based size. -> ReadBuffer(const void**, CKDWORD*)
|
|
ReadAndFillBuffer_LEndian16(int, void*) User give Byte based size. -> ReadBuffer(const void**, CKDWORD)
|
|
ReadAndFillBuffer_LEndian16(void*) Read Byte based size. -> ReadBuffer(const void**, CKDWORD*)
|
|
*/
|
|
|
|
/**
|
|
* @brief Read buffer and copy it.
|
|
*
|
|
* The copied buffer and the size of buffer will be returned to caller.
|
|
* Caller should free the buffer by calling CKStateChunk::DeleteBuffer(void*).
|
|
*
|
|
* @param ppData[out] The pointer to pointer holding the new copied data.
|
|
* @param size_in_byte[out] Set to the size of buffer when success.
|
|
* @return True if success.
|
|
* @remark Following original Virtools functions can use this function to implement:
|
|
* + ReadBuffer(void**)
|
|
*/
|
|
bool ReadBuffer(void** ppData, CKDWORD* size_in_byte);
|
|
/**
|
|
* @brief Free the buffer allocated by CKStateChunk reading functions.
|
|
* @param buf[in] The buffer need to be free.
|
|
* @see ReadBuffer
|
|
*/
|
|
void DeleteBuffer(const void* buf);
|
|
/**
|
|
* @brief A RAII wrapper for ReadAndCopyBuffer(void**, CKDWORD*)
|
|
* @return Buffer_t (actually is a std::unique_ptr with custom deleter)
|
|
* @remark
|
|
* + The return value is std::unique_ptr but its deleter have more features.
|
|
* + If return value containing value is nullptr, it mean this function is failed.
|
|
* + Use Buffer_t.get_deleter().GetBufferSize() to get the size of buffer.
|
|
* + You can use Buffer_t.reset() to force free the return value.
|
|
* @remark Here is a exmaple about how to use this function
|
|
* ```
|
|
* Buffer_t buf = chunk->ReadBufferWrapper(114);
|
|
* if (buf) {
|
|
* stuff(buf.get(), buf.get_deleter().GetBufferSize()); // do some operation...
|
|
* buf.reset(); // immediately free it.
|
|
* }
|
|
* ```
|
|
*/
|
|
Buffer_t ReadBufferWrapper();
|
|
|
|
/**
|
|
* @brief Read buffer and fill user struct.
|
|
*
|
|
* The size of buffer will be read from CKStateChunk internally and return to caller.
|
|
*
|
|
* @param pData[out] The pointer holding the data.
|
|
* @return True if success.
|
|
* @remark Following original Virtools functions can use this function to implement:
|
|
* + ReadAndFillBuffer(void*)
|
|
* + ReadAndFillBuffer_LEndian(void*)
|
|
* + ReadAndFillBuffer_LEndian16(void*)
|
|
*/
|
|
bool ReadAndFillBuffer(void* pData);
|
|
/**
|
|
* @brief Read buffer and fill user struct.
|
|
*
|
|
* The size of buffer is provided by user.
|
|
*
|
|
* @param pData[out] The pointer holding the data.
|
|
* @param size_in_byte[in] The size of data which you want to read in byte unit
|
|
* @return True if success.
|
|
* @remark Following original Virtools functions can use this function to implement:
|
|
* + ReadAndFillBuffer(int, void*)
|
|
* + ReadAndFillBuffer_LEndian(int, void*)
|
|
* + ReadAndFillBuffer_LEndian16(int, void*)
|
|
*/
|
|
bool ReadAndFillBuffer(void* pData, CKDWORD size_in_byte);
|
|
|
|
/* ========== Sequence Functions ==========*/
|
|
|
|
/// <summary>
|
|
/// Read Object ID Sequence
|
|
/// <para>The combination using of StartReadSequence(), ReadObjectID(), and ReadObject() redirect to this.</para>
|
|
/// </summary>
|
|
/// <param name="ls"></param>
|
|
/// <returns></returns>
|
|
bool ReadObjectIDSequence(XContainer::XObjectArray* ls);
|
|
inline bool ReadObjectIDSequence(XContainer::XObjectArray& ls) {
|
|
return ReadObjectIDSequence(&ls);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read Manager Sequence
|
|
/// <para>The combination using of StartManagerReadSequence() and ReadManagerIntSequence() redirect to this.</para>
|
|
/// </summary>
|
|
/// <param name="guid"></param>
|
|
/// <param name="ls"></param>
|
|
/// <returns></returns>
|
|
bool ReadManagerIntSequence(CKGUID* guid, XContainer::XArray<CKINT>* ls);
|
|
inline bool ReadManagerIntSequence(CKGUID& guid, XContainer::XArray<CKINT>& ls) {
|
|
return ReadManagerIntSequence(&guid, &ls);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read Sub Chunk Sequence
|
|
/// <para>The combination using of StartReadSequence() and ReadSubChunk() redirect to this.</para>
|
|
/// <para>The item of returned CKStateChunk* list should be manually released!</para>
|
|
/// </summary>
|
|
/// <param name="ls"></param>
|
|
/// <returns></returns>
|
|
bool ReadSubChunkSequence(XContainer::XArray<CKStateChunk*>* ls);
|
|
inline bool ReadSubChunkSequence(XContainer::XArray<CKStateChunk*>& ls) {
|
|
return ReadSubChunkSequence(&ls);
|
|
}
|
|
|
|
/**
|
|
* @brief Read Object Array (actually still is CK_ID)
|
|
* @remark ReadObjectArray() and XObjectArray::Load redirect to this.
|
|
* @param ls The list
|
|
* @return True if success.
|
|
*/
|
|
bool ReadXObjectArray(XContainer::XObjectArray* ls);
|
|
inline bool ReadXObjectArray(XContainer::XObjectArray& ls) {
|
|
return ReadXObjectArray(&ls);
|
|
}
|
|
|
|
/**
|
|
* @brief Read Object Array (actually is CKObject*)
|
|
* @remark ReadXObjectArray() and XObjectPointerArray::Load redirect to this.
|
|
* @param ls The list
|
|
* @return True if success
|
|
*/
|
|
bool ReadXObjectPointerArray(XContainer::XObjectPointerArray* ls);
|
|
inline bool ReadXObjectPointerArray(XContainer::XObjectPointerArray& ls) {
|
|
return ReadXObjectPointerArray(&ls);
|
|
}
|
|
|
|
//int ReadInt();
|
|
//int StartReadSequence();
|
|
//CK_ID ReadObjectID();
|
|
//CKStateChunk* ReadSubChunk();
|
|
//int StartManagerReadSequence(CKGUID* guid);
|
|
//CKGUID ReadGuid();
|
|
//void ReadAndFillBuffer_LEndian(void* buffer);
|
|
//void ReadAndFillBuffer_LEndian16(void* buffer);
|
|
//float ReadFloat();
|
|
//CKWORD ReadWord();
|
|
//CKDWORD ReadDword();
|
|
//CKDWORD ReadDwordAsWords();
|
|
//void ReadVector(VxMath::VxVector* v);
|
|
//void ReadMatrix(VxMath::VxMatrix& mat);
|
|
//CKObjectImplements::CKObject* ReadObject(CKMinContext*);
|
|
//void ReadAndFillBuffer(void* buffer);
|
|
//CKBYTE* ReadRawBitmap(VxMath::VxImageDescEx& desc);
|
|
//XObjectArray ReadXObjectArray(void);
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Write Function
|
|
|
|
public:
|
|
void StartWrite();
|
|
//void WriteIdentifier(CKDWORD id);
|
|
//void AddChunkAndDelete(CKStateChunk*);
|
|
//void StartObjectIDSequence(int count);
|
|
//void WriteObjectSequence(CKObjectImplements::CKObject* obj);
|
|
//void WriteInt(int data);
|
|
//void WriteFloat(float data);
|
|
//void WriteDword(CKDWORD data);
|
|
//void WriteDwordAsWords(CKDWORD data);
|
|
//void WriteVector(const VxMath::VxVector* v);
|
|
//void WriteMatrix(const VxMath::VxMatrix& mat);
|
|
//void WriteObject(CKObjectImplements::CKObject* obj);
|
|
//void WriteBuffer_LEndian(int size, void* buf);
|
|
//void WriteBuffer_LEndian16(int size, void* buf);
|
|
//void WriteBufferNoSize_LEndian(int size, void* buf);
|
|
///*void UpdateDataSize();*/
|
|
//void* LockWriteBuffer(int DwordCount);
|
|
|
|
/*
|
|
* Old Name: CloseChunk();
|
|
*/
|
|
void StopWrite(void);
|
|
|
|
bool LockWriteBuffer(const void** ppData, CKDWORD size_in_byte);
|
|
bool UnLockWriteBuffer(CKDWORD size_in_byte);
|
|
LockedWriteBuffer_t LockWriteBufferWrapper(CKDWORD size_in_byte);
|
|
|
|
#pragma endregion
|
|
|
|
|
|
|
|
};
|
|
|
|
}
|