libcmo21/Documents/Recorder.txt

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 ChunkIteratorData {  // 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;
};