403 lines
11 KiB
Plaintext
403 lines
11 KiB
Plaintext
CKFile in VT21: 0xC8, 200, count50; in VT25: 0xE0, 224, count 56
|
|
lost 24 byte, 6 fields or 2 lists
|
|
|
|
|
|
|
|
Important CK Class size
|
|
CKObject no change. 0x14(20)
|
|
CKSceneObject no change 0x1C(28), share Load/Save with CKObject
|
|
|
|
CKBehavior no change 0x6C(108)
|
|
CKBeObject 0x50(80) count 20
|
|
|
|
CKGroup 0x68(104) count 26
|
|
CKMaterial 0xF0(240) count 90
|
|
CKTexture 0x94(148) count 52
|
|
CKMesh 0x104(260) count 65
|
|
|
|
CKRenderObject 0x58(88) count 22, share Load/Save with CKBeObject
|
|
CK3dEntity 0x1A8(424) count 106
|
|
CK3dObject 0x1A8(424) count 106 same as CK3dEntity
|
|
|
|
|
|
|
|
m_FileName
|
|
in VT21 +34, 136
|
|
in VT25 +31, 124
|
|
|
|
m_MappedFile
|
|
in VT21 +37, 148
|
|
in VT25 +34, 136
|
|
|
|
m_Context
|
|
in VT21 +35, 140
|
|
in VT25 +32, 128
|
|
|
|
VxMemoryMappedFile and CKFileInfo seems no change
|
|
CKFileObject still no change
|
|
CKFilePluginDependencies still no change
|
|
CKFileManagerData no change (12)
|
|
|
|
CKStateChunk is 0x28u black box
|
|
CKBufferParser also is 0x10u black box
|
|
|
|
typedef char* CKSTRING;
|
|
typedef char CKCHAR;
|
|
typedef int CKBOOL;
|
|
typedef unsigned char CKBYTE;
|
|
typedef unsigned int CKDWORD;
|
|
typedef unsigned short CKWORD;
|
|
typedef int CKERROR;
|
|
typedef void* CKSOUNDHANDLE;
|
|
typedef int CKParameterType;
|
|
typedef int CKOperationType;
|
|
typedef int CKMessageType;
|
|
typedef int CKAttributeType;
|
|
typedef int CKAttributeCategory;
|
|
|
|
|
|
struct CKGUID {
|
|
DWORD d1,d2;
|
|
};
|
|
|
|
struct XBaseString {
|
|
// the string
|
|
char* m_Buffer;
|
|
// the length of the string
|
|
WORD m_Length;
|
|
// the allocated size
|
|
WORD m_Allocated;
|
|
};
|
|
|
|
struct XArray {
|
|
// elements start {secret}
|
|
DWORD* m_Begin;
|
|
// elements end {secret}
|
|
DWORD* m_End;
|
|
// reserved end {secret}
|
|
DWORD* m_AllocatedEnd;
|
|
};
|
|
struct XIntArray {
|
|
int* m_Begin;
|
|
int* m_End;
|
|
int* m_AllocatedEnd;
|
|
};
|
|
struct XClassArray {
|
|
DWORD* m_Begin;
|
|
DWORD* m_End;
|
|
DWORD* m_AllocatedEnd;
|
|
};
|
|
struct XSArray {
|
|
DWORD* m_Begin;
|
|
DWORD* m_End;
|
|
};
|
|
struct XBitArray {
|
|
DWORD m_Data_Flags;
|
|
DWORD m_Size;
|
|
};
|
|
|
|
struct CKAttributeVal {
|
|
CKAttributeType AttribType;
|
|
CK_ID Parameter;
|
|
};
|
|
|
|
struct VxImageDescEx {
|
|
int Size; // Size of the structure
|
|
DWORD Flags; // Reserved for special formats (such as compressed ) 0 otherwise
|
|
|
|
int Width; // Width in pixel of the image
|
|
int Height; // Height in pixel of the image
|
|
union {
|
|
int BytesPerLine; // Pitch (width in bytes) of the image
|
|
int TotalImageSize; // For compressed image (DXT1...) the total size of the image
|
|
};
|
|
int BitsPerPixel; // Number of bits per pixel
|
|
union {
|
|
DWORD RedMask; // Mask for Red component
|
|
DWORD BumpDuMask; // Mask for Bump Du component
|
|
};
|
|
union {
|
|
DWORD GreenMask; // Mask for Green component
|
|
DWORD BumpDvMask; // Mask for Bump Dv component
|
|
};
|
|
union {
|
|
DWORD BlueMask; // Mask for Blue component
|
|
DWORD BumpLumMask; // Mask for Luminance component
|
|
|
|
};
|
|
DWORD AlphaMask; // Mask for Alpha component
|
|
|
|
short BytesPerColorEntry; // ColorMap Stride
|
|
short ColorMapEntries; // If other than 0 image is palletized
|
|
|
|
BYTE* ColorMap; // Palette colors
|
|
BYTE* Image; // Image
|
|
};
|
|
|
|
// <T, K> = <int, CK_ID>
|
|
struct XHashTable_int_int_::Entry
|
|
{
|
|
int key;
|
|
int data;
|
|
struct XHashTable_int_int_::Entry *next;
|
|
} *XHashTable_int_int_::pEntry;
|
|
struct XHashTable_int_int_ {
|
|
struct XHashTable_int_int_::XSArray_pEntry_ {
|
|
XHashTable_int_int_::pEntry* m_Begin;
|
|
XHashTable_int_int_::pEntry* m_End;
|
|
}m_Table;
|
|
struct XHashTable_int_int_::XClassArray_pEntry_ {
|
|
XHashTable_int_int_::Entry* m_Begin;
|
|
XHashTable_int_int_::Entry* m_End;
|
|
XHashTable_int_int_::Entry* m_AllocatedEnd;
|
|
}m_Pool;
|
|
};
|
|
struct XHashTable_int_int_::Iterator {
|
|
XHashTable_int_int_::pEntry m_Node;
|
|
XHashTable_int_int_* m_Table;
|
|
};
|
|
typedef XHashTable_int_int_ XFileObjectsTable;
|
|
typedef XHashTable_int_int_ XAttributeList;
|
|
|
|
|
|
struct CKObject {
|
|
DWORD* vtable;
|
|
CK_ID m_ID;
|
|
CKSTRING m_Name;
|
|
CKDWORD m_ObjectFlags;
|
|
CKContext *m_Context;
|
|
};
|
|
|
|
struct CKSceneObject : CKObject {
|
|
XBitArray m_Scenes;
|
|
};
|
|
struct CKBeObject : CKSceneObject {
|
|
XBitArray m_Groups;
|
|
XArray* m_ScriptArray;
|
|
XArray* m_LastFrameMessages;
|
|
DWORD m_Waiting; // expanded from unsigned short
|
|
DWORD m_Priority; // expanded from signed short
|
|
float m_LastExecutionTime;
|
|
XAttributeList* m_Attributes;
|
|
CKDWORD* m_unknow15;
|
|
CKDWORD m_unknow16;
|
|
CKDWORD m_AttributeCount;
|
|
CKDWORD m_unknow18;
|
|
CKDWORD m_unknow19;
|
|
};
|
|
|
|
struct BehaviorBlockData{};
|
|
struct BehaviorGraphData{};
|
|
struct CKBehavior : CKSceneObject {
|
|
CK_ID m_Owner;
|
|
CK_ID m_BehParent;
|
|
XSObjectPointerArray m_InputArray;
|
|
XSObjectPointerArray m_OutputArray;
|
|
XSObjectPointerArray m_InParameter;
|
|
XSObjectPointerArray m_OutParameter;
|
|
XSObjectPointerArray m_LocalParameter;
|
|
CK_CLASSID m_CompatibleClassID;
|
|
int m_Priority;
|
|
CKDWORD m_Flags;
|
|
CKStateChunk * m_InterfaceChunk;
|
|
BehaviorGraphData* m_GraphData;
|
|
BehaviorBlockData* m_BlockData;
|
|
float m_LastExecutionTime;
|
|
CK_ID m_InputTargetParam;
|
|
};
|
|
|
|
struct CKFileInfo
|
|
{
|
|
DWORD ProductVersion; // Virtools Version (Dev/Creation). (CK_VIRTOOLS_VERSION)
|
|
DWORD ProductBuild; // Virtools Build Number.
|
|
DWORD FileWriteMode; // Options used to save this file. (CK_FILE_WRITEMODE)
|
|
DWORD FileVersion; // Version of file format when file was saved.
|
|
DWORD CKVersion; // Version of CK when file was saved.
|
|
DWORD FileSize; // Size of file in bytes.
|
|
DWORD ObjectCount; // Number of objects stored in the file.
|
|
DWORD ManagerCount; // Number of managers which saved data in the file.
|
|
DWORD MaxIDSaved; // Maximum Object identifier saved
|
|
DWORD Crc; // Crc of data
|
|
DWORD Hdr1PackSize; // Reserved
|
|
DWORD Hdr1UnPackSize; // Reserved
|
|
DWORD DataPackSize; // Reserved
|
|
DWORD DataUnPackSize; // Reserved
|
|
};
|
|
|
|
struct CKFileObject {
|
|
CK_ID Object; // ID of the object being load/saved (as it will be/was saved in the file)
|
|
CK_ID CreatedObject; // ID of the object being created
|
|
CK_CLASSID ObjectCid; // Class Identifier of the object
|
|
CKObject* ObjPtr; // A pointer to the object itself (as CreatedObject when loading)
|
|
CKSTRING Name; // Name of the Object
|
|
CKStateChunk* Data; // A CKStateChunk that contains object information
|
|
int PostPackSize; // When compressed chunk by chunk : size of Data after compression
|
|
int PrePackSize; // When compressed chunk by chunk : size of Data before compression
|
|
CK_FO_OPTIONS Options; // When loading an object it may be renamed , use to replace another object
|
|
int FileIndex; // Position of the object data inside uncompressed file buffer
|
|
CKDWORD SaveFlags; // Flags used when this object was saved.
|
|
};
|
|
|
|
struct CKFileManagerData {
|
|
CKStateChunk *data;
|
|
CKGUID Manager;
|
|
}
|
|
|
|
struct CKFilePluginDependencies{
|
|
int m_PluginCategory;
|
|
XArray/*<CKGUID>*/ m_Guids;
|
|
XBitArray ValidGuids;
|
|
};
|
|
|
|
struct VxMemoryMappedFile {
|
|
void* m_hFile;
|
|
void* m_hFileMapping; // Handle of memory mapped file
|
|
void* m_pMemoryMappedFileBase;
|
|
DWORD m_cbFile;
|
|
DWORD m_errCode;
|
|
};
|
|
|
|
struct CKStateChunkParser {
|
|
DWORD m_CurrentPos;
|
|
DWORD m_DataSize;
|
|
DWORD m_PrevIdentifierPos;
|
|
};
|
|
struct IntListStruct {
|
|
DWORD m_Count;
|
|
DWORD m_Allocated;
|
|
DWORD* m_pData;
|
|
};
|
|
struct CKStateChunkProp {
|
|
WORD m_DataVersion;
|
|
WORD m_ChunkVersion;
|
|
};
|
|
struct CKStateChunk {
|
|
CK_CLASSID m_ClassId;
|
|
|
|
DWORD m_DataDwordSize;
|
|
DWORD* m_pData;
|
|
|
|
CKStateChunkProp m_ChunkProps;
|
|
|
|
CKStateChunkParser* m_Parser;
|
|
|
|
IntListStruct* m_ObjectIdList;
|
|
IntListStruct* m_SubChunkList;
|
|
IntListStruct* m_ManagerIntList;
|
|
|
|
CKFile* m_BindFile;
|
|
DWORD m_unknow;
|
|
};
|
|
struct CKStateChunkRemap { // 0x40 count 16
|
|
DWORD m_ChunkVersion;
|
|
DWORD* m_pData;
|
|
DWORD m_DataDwordSize;
|
|
DWORD unknow_3;
|
|
DWORD* m_ObjList_pData;
|
|
DWORD m_ObjList_Count;
|
|
DWORD* m_ChkList_pData;
|
|
DWORD m_ChkList_Count;
|
|
|
|
DWORD unknow_8;
|
|
DWORD unknow_9;
|
|
DWORD unknow_10;
|
|
DWORD unknow_11;
|
|
DWORD unknow_12;
|
|
DWORD unknow_13;
|
|
|
|
CKDependenciesContext* m_DepCtx;
|
|
CKContext* m_Ctx;
|
|
};
|
|
|
|
|
|
|
|
struct CKBufferParser {
|
|
char* m_MemBegin;
|
|
DWORD m_MemPos;
|
|
CKBOOL m_NeedManualFree;
|
|
DWORD m_MemSize;
|
|
};
|
|
|
|
struct XArray_CKFileObject_ {
|
|
CKFileObject* m_Begin;
|
|
CKFileObject* m_End;
|
|
CKFileObject* m_AllocatedEnd;
|
|
};
|
|
struct XArray_CKFileManagerData_ {
|
|
CKFileManagerData* m_Begin;
|
|
CKFileManagerData* m_End;
|
|
CKFileManagerData* m_AllocatedEnd;
|
|
};
|
|
struct XClassArray_CKFilePluginDependencies_ {
|
|
CKFilePluginDependencies* m_Begin;
|
|
CKFilePluginDependencies* m_End;
|
|
CKFilePluginDependencies* m_AllocatedEnd;
|
|
};
|
|
struct XClassArray_XIntArray_ {
|
|
XIntArray* m_Begin;
|
|
XIntArray* m_End;
|
|
XIntArray* m_AllocatedEnd;
|
|
};
|
|
struct XClassArray_XString_ {
|
|
XString* m_Begin;
|
|
XString* m_End;
|
|
XString* m_AllocatedEnd;
|
|
};
|
|
|
|
struct CKFile {
|
|
// 0
|
|
int m_SaveIDMax; // Maximum CK_ID found when saving or loading objects {secret}
|
|
XArray_CKFileObject_ m_FileObjects; // List of objects being saved / loaded {secret}
|
|
XArray_CKFileManagerData_ m_ManagersData; // Manager Data loaded {secret}
|
|
XClassArray_CKFilePluginDependencies_ m_PluginsDep; // Plugins dependencies for this file {secret}
|
|
XClassArray_XIntArray_ m_IndexByClassId; // List of index in the m_FileObjects table sorted by ClassID {secret}
|
|
XClassArray_XString_ m_IncludedFiles; // List of files that should be inserted in the CMO file. {secret}
|
|
// 16
|
|
CKFileInfo m_FileInfo; // Headers summary {secret}
|
|
// 16 + 14 = 30
|
|
// guess
|
|
DWORD unknow_fields;
|
|
XBitArray m_AlreadySavedMask; // BitArray of IDs already saved {secret}
|
|
// 30 + 3 = 33
|
|
CKDWORD m_Flags; // Flags used to save file {secret} CK_LOAD_FLAGS
|
|
CKSTRING m_FileName; // Current file name {secret}
|
|
CKContext* m_Context; // CKContext on which file is loaded/Saved {secret}
|
|
CKBufferParser* m_Parser;
|
|
VxMemoryMappedFile* m_MappedFile;
|
|
// 33 + 5 = 38
|
|
// guess
|
|
XFileObjectsTable m_ObjectsHashTable;
|
|
// 38 + 5 = 43
|
|
//[guess]
|
|
CKBOOL m_SceneSaved;
|
|
CKBOOL m_ReadFileDataDone;
|
|
// 43 + 2 = 45
|
|
XBitArray m_AlreadyReferencedMask; // BitArray of IDs already referenced {secret}
|
|
XObjectPointerArray m_ReferencedObjects;
|
|
// 45 + 2 + 3 = 50
|
|
};
|
|
|
|
VxTimeProfiler m_Chrono;
|
|
|
|
XFileObjectsTable m_ObjectsHashTable;
|
|
//#ifdef USECHUNKTABLE
|
|
XClassArray/*<CKFileChunk>*/ m_FileChunks; // Instead of allocating chunk per chunk a whole memory buffer is allocated to store all chunks and their readers
|
|
CKFileChunk* m_ObjectChunks;
|
|
CKFileChunk* m_ManagersChunks;
|
|
VxMemoryPool m_ChunkBuffers; // Store all decompressed file buffer in memory so that all chunks directly points to it...
|
|
// can only work for recent files ( > 2.0)
|
|
BYTE* m_CurrentChunkBufferPtr;
|
|
//#endif
|
|
|
|
CKBOOL m_ReadFileDataDone;
|
|
CKBOOL m_SceneSaved;
|
|
//-----------
|
|
XIntArray m_DuplicateNameFounds; // A List of file object index for which a existing object with the same name has been
|
|
// found, this list is build if the load option contains CK_LOAD_AUTOMATICMODE or CK_LOAD_DODIALOG
|
|
|
|
//-----
|
|
XBitArray m_AlreadySavedMask; // BitArray of IDs already saved {secret}
|
|
XBitArray m_AlreadyReferencedMask; // BitArray of IDs already referenced {secret}
|
|
XObjectPointerArray m_ReferencedObjects;
|
|
};
|