From 0242cb60c499841a844767e4fd5e0ade1c9803d0 Mon Sep 17 00:00:00 2001 From: yyc12345 Date: Tue, 28 Feb 2023 14:04:38 +0800 Subject: [PATCH] update shit --- LibCmo/CKDefines.hpp | 2 + LibCmo/CKEnums.hpp | 2 + LibCmo/CKFile.cpp | 97 ++- LibCmo/CKFile.hpp | 16 +- LibCmo/CKFileReader.cpp | 4 +- LibCmo/CKIdentifiers.hpp | 736 +++++++++++++++++++ LibCmo/CKManagerImplements/CKBaseManager.cpp | 7 + LibCmo/CKObjectImplements/CKObject.cpp | 29 + LibCmo/CKObjects.hpp | 13 +- LibCmo/CKStateChunk.cpp | 6 +- LibCmo/CKStateChunk.hpp | 34 +- LibCmo/LibCmo.vcxproj | 1 + LibCmo/LibCmo.vcxproj.filters | 3 + LibCmo/VTUtils.hpp | 31 +- Unvirt/StructFormatter.cpp | 4 +- Unvirt/Unvirt.cpp | 2 +- 16 files changed, 941 insertions(+), 46 deletions(-) create mode 100644 LibCmo/CKIdentifiers.hpp diff --git a/LibCmo/CKDefines.hpp b/LibCmo/CKDefines.hpp index 24f0aba..f7a01fd 100644 --- a/LibCmo/CKDefines.hpp +++ b/LibCmo/CKDefines.hpp @@ -86,6 +86,8 @@ namespace LibCmo { CKGUID& operator=(const CKGUID& rhs) { this->d1 = rhs.d1; this->d2 = rhs.d2; + + return *this; } bool operator ==(const CKGUID& rhs) const { diff --git a/LibCmo/CKEnums.hpp b/LibCmo/CKEnums.hpp index e3db7a4..a84e18b 100644 --- a/LibCmo/CKEnums.hpp +++ b/LibCmo/CKEnums.hpp @@ -6,6 +6,8 @@ namespace LibCmo::CK2 { + constexpr const CKDWORD CKVERSION = 0x05082002; + namespace PredefinedGuids { constexpr const CKDWORD OBJECT_MANAGER_GUID1 = 0x7cbb3b91; diff --git a/LibCmo/CKFile.cpp b/LibCmo/CKFile.cpp index 562b945..132527e 100644 --- a/LibCmo/CKFile.cpp +++ b/LibCmo/CKFile.cpp @@ -21,7 +21,38 @@ namespace LibCmo::CK2 { #pragma region CKFileInfo - CKFileInfo::CKFileInfo() { + CKFileInfo::CKFileInfo() : + ProductVersion(0u), ProductBuild(0x01010000u), FileWriteMode(CK_FILE_WRITEMODE::CKFILE_UNCOMPRESSED), + FileVersion(8u), CKVersion(CKVERSION), FileSize(0u), + ObjectCount(0u), ManagerCount(0u), MaxIDSaved(0u), Crc(0u), + Hdr1PackSize(0u), Hdr1UnPackSize(0u), DataPackSize(0u), DataUnPackSize(0u) { + } + + CKFileInfo::CKFileInfo(const CKFileInfo& rhs) : + ProductVersion(rhs.ProductVersion), ProductBuild(rhs.ProductBuild), FileWriteMode(rhs.FileWriteMode), + FileVersion(rhs.FileVersion), CKVersion(rhs.CKVersion), FileSize(rhs.FileSize), + ObjectCount(rhs.ObjectCount), ManagerCount(rhs.ManagerCount), MaxIDSaved(rhs.MaxIDSaved), Crc(rhs.Crc), + Hdr1PackSize(rhs.Hdr1PackSize), Hdr1UnPackSize(rhs.Hdr1UnPackSize), + DataPackSize(rhs.DataPackSize), DataUnPackSize(rhs.DataUnPackSize) { + } + + CKFileInfo& CKFileInfo::operator=(const CKFileInfo& rhs) { + this->ProductVersion = rhs.ProductVersion; + this->ProductBuild = rhs.ProductBuild; + this->FileWriteMode = rhs.FileWriteMode; + this->FileVersion = rhs.FileVersion; + this->CKVersion = rhs.CKVersion; + this->FileSize = rhs.FileSize; + this->ObjectCount = rhs.ObjectCount; + this->ManagerCount = rhs.ManagerCount; + this->MaxIDSaved = rhs.MaxIDSaved; + this->Crc = rhs.Crc; + this->Hdr1PackSize = rhs.Hdr1PackSize; + this->Hdr1UnPackSize = rhs.Hdr1UnPackSize; + this->DataPackSize = rhs.DataPackSize; + this->DataUnPackSize = rhs.DataUnPackSize; + + return *this; } CKFileInfo::~CKFileInfo() { @@ -32,8 +63,32 @@ namespace LibCmo::CK2 { #pragma region CKFileObject CKFileObject::CKFileObject() : - Data(nullptr) { - ; + ObjectId(0u), ObjectCid(CK_CLASSID::CKCID_OBJECT), Name(), + Data(nullptr), FileIndex(0u) { + } + + CKFileObject::CKFileObject(const CKFileObject& rhs) : + ObjectId(rhs.ObjectId), ObjectCid(rhs.ObjectCid), Name(rhs.Name), + Data(rhs.Data), FileIndex(rhs.FileIndex) { + + if (this->Data != nullptr) { + this->Data = new(std::nothrow) CKStateChunk(*(rhs.Data)); + } + + } + + CKFileObject& CKFileObject::operator=(const CKFileObject& rhs) { + this->ObjectId = rhs.ObjectId; + this->ObjectCid = rhs.ObjectCid; + this->Name = rhs.Name; + this->FileIndex = rhs.FileIndex; + + this->Data = rhs.Data; + if (this->Data != nullptr) { + this->Data = new(std::nothrow) CKStateChunk(*(rhs.Data)); + } + + return *this; } CKFileObject::~CKFileObject() { @@ -45,7 +100,27 @@ namespace LibCmo::CK2 { #pragma region CKFileManagerData CKFileManagerData::CKFileManagerData() : - Data(nullptr) { + Data(nullptr), Manager(0u, 0u) { + } + + CKFileManagerData::CKFileManagerData(const CKFileManagerData& rhs) : + Data(rhs.Data), Manager(rhs.Manager) { + + if (this->Data != nullptr) { + this->Data = new(std::nothrow) CKStateChunk(*(rhs.Data)); + } + + } + + CKFileManagerData& CKFileManagerData::operator=(const CKFileManagerData& rhs) { + this->Manager = rhs.Manager; + + this->Data = rhs.Data; + if (this->Data != nullptr) { + this->Data = new(std::nothrow) CKStateChunk(*(rhs.Data)); + } + + return *this; } CKFileManagerData::~CKFileManagerData() { @@ -56,7 +131,19 @@ namespace LibCmo::CK2 { #pragma region CKFilePluginDependencies - CKFilePluginDependencies::CKFilePluginDependencies() { + CKFilePluginDependencies::CKFilePluginDependencies() : + m_PluginCategory(CK_PLUGIN_TYPE::CKPLUGIN_MANAGER_DLL), m_Guids() { + } + + CKFilePluginDependencies::CKFilePluginDependencies(const CKFilePluginDependencies& rhs) : + m_PluginCategory(rhs.m_PluginCategory), m_Guids(rhs.m_Guids) { + } + + CKFilePluginDependencies& CKFilePluginDependencies::operator=(const CKFilePluginDependencies& rhs) { + this->m_PluginCategory = rhs.m_PluginCategory; + this->m_Guids = rhs.m_Guids; + + return *this; } CKFilePluginDependencies::~CKFilePluginDependencies() { diff --git a/LibCmo/CKFile.hpp b/LibCmo/CKFile.hpp index 1aca6a7..129a196 100644 --- a/LibCmo/CKFile.hpp +++ b/LibCmo/CKFile.hpp @@ -59,8 +59,8 @@ namespace LibCmo::CK2 { class CKFileInfo { public: CKFileInfo(); - CKFileInfo(const CKFileInfo&) = delete; - CKFileInfo& operator=(const CKFileInfo&) = delete; + CKFileInfo(const CKFileInfo&); + CKFileInfo& operator=(const CKFileInfo&); ~CKFileInfo(); CKDWORD ProductVersion; // Virtools Version (Dev/Creation). (CK_VIRTOOLS_VERSION) @@ -84,8 +84,8 @@ namespace LibCmo::CK2 { class CKFileObject { public: CKFileObject(); - //CKFileObject(const CKFileObject&) = delete; - //CKFileObject& operator=(const CKFileObject&) = delete; + CKFileObject(const CKFileObject&); + CKFileObject& operator=(const CKFileObject&); ~CKFileObject(); CK_ID ObjectId; @@ -100,8 +100,8 @@ namespace LibCmo::CK2 { class CKFileManagerData { public: CKFileManagerData(); - //CKFileManagerData(const CKFileManagerData&) = delete; - //CKFileManagerData& operator=(const CKFileManagerData&) = delete; + CKFileManagerData(const CKFileManagerData&); + CKFileManagerData& operator=(const CKFileManagerData&); ~CKFileManagerData(); CKStateChunk* Data; @@ -113,8 +113,8 @@ namespace LibCmo::CK2 { class CKFilePluginDependencies { public: CKFilePluginDependencies(); - //CKFilePluginDependencies(const CKFilePluginDependencies&) = delete; - //CKFilePluginDependencies& operator=(const CKFilePluginDependencies&) = delete; + CKFilePluginDependencies(const CKFilePluginDependencies&); + CKFilePluginDependencies& operator=(const CKFilePluginDependencies&); ~CKFilePluginDependencies(); CK_PLUGIN_TYPE m_PluginCategory; diff --git a/LibCmo/CKFileReader.cpp b/LibCmo/CKFileReader.cpp index f8b5f82..3799154 100644 --- a/LibCmo/CKFileReader.cpp +++ b/LibCmo/CKFileReader.cpp @@ -71,7 +71,7 @@ namespace LibCmo::CK2 { // force reset too big product ver? if (rawHeader.ProductVersion >= 12u) { rawHeader.ProductVersion = 0u; - rawHeader.ProductBuild = 0x01010000; + rawHeader.ProductBuild = 0x01010000u; } // ========== assign value ========== @@ -393,7 +393,9 @@ namespace LibCmo::CK2 { // todo: special treat for CK_LEVEL // try parsing data + obj.Data->StartRead(); CKERROR err = createdObjs[index]->Load(obj.Data, shallowDoc.get()); + obj.Data->StopRead(); if (err != CKERROR::CKERR_OK) { delete (createdObjs[index]); createdObjs[index] = nullptr; diff --git a/LibCmo/CKIdentifiers.hpp b/LibCmo/CKIdentifiers.hpp new file mode 100644 index 0000000..e259858 --- /dev/null +++ b/LibCmo/CKIdentifiers.hpp @@ -0,0 +1,736 @@ +#pragma once + +#include "CKDefines.hpp" +#include +#include + +namespace LibCmo::CK2::Identifiers { + + constexpr const CKDWORD CK_STATESAVE_ALL = 0xFFFFFFFF; + + //------------------------------------------------ + // Object + enum class CK_STATESAVEFLAGS_OBJECT : uint32_t { + + CK_STATESAVE_NAME = 0x00000001, // Obsolete + CK_STATESAVE_ID = 0x00000002, // Obsolete + CK_STATESAVE_OBJECTHIDDEN = 0x00000004, // The object is hidden + CK_STATESAVE_OBJECTHIERAHIDDEN = 0x00000018, // The object is hidden hierarchically + CK_STATESAVE_OBJECTALL = 0x0000000F + }; + + + //------------------------------------------------ + // Be Object + enum class CK_STATESAVEFLAGS_BEOBJECT : uint32_t { + + CK_STATESAVE_ATTRIBUTES = 0x00000010, // Obsolete + CK_STATESAVE_NEWATTRIBUTES = 0x00000011, // Save Attributes + CK_STATESAVE_GROUPS = 0x00000020, // Obsolete + CK_STATESAVE_DATAS = 0x00000040, // Save Flags and (Waiting for message) status + CK_STATESAVE_SOUNDS = 0x00000080, // Obsolete + CK_STATESAVE_BEHAVIORS = 0x00000100, // Obsolete + CK_STATESAVE_PARAMETERS = 0x00000200, // Obsolete + CK_STATESAVE_SINGLEACTIVITY = 0x00000400, // SINGLE ACTIVITY + CK_STATESAVE_SCRIPTS = 0x00000800, // Obsolete + CK_STATESAVE_BEOBJECTONLY = 0x00000FF0, // Save only BeObject specific datas + CK_STATESAVE_BEOBJECTALL = 0x00000FFF // Save All datas + }; + + + //------------------------------------------------ + // 3dEntity + enum class CK_STATESAVEFLAGS_3DENTITY : uint32_t { + + CK_STATESAVE_3DENTITYSKINDATANORMALS = 0x00001000, // Save Skin normals + CK_STATESAVE_ANIMATION = 0x00002000, // Obsolete + CK_STATESAVE_MESHS = 0x00004000, // Save List of mesh + CK_STATESAVE_PARENT = 0x00008000, // Save Parent + CK_STATESAVE_3DENTITYFLAGS = 0x00010000, // Save Flags + CK_STATESAVE_3DENTITYMATRIX = 0x00020000, // Save Position/orientation/Scale + CK_STATESAVE_3DENTITYHIERARCHY = 0x00040000, // obsolete + CK_STATESAVE_3DENTITYPLACE = 0x00080000, // Save Place in which the Entity is referenced + CK_STATESAVE_3DENTITYNDATA = 0x00100000, // Reserved for future use + CK_STATESAVE_3DENTITYSKINDATA = 0x00200000, // Save Skin data + CK_STATESAVE_3DENTITYONLY = 0x003FF000, // Save only 3dEntity specific datas + CK_STATESAVE_3DENTITYALL = 0x003FFFFF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // Light + enum class CK_STATESAVEFLAGS_LIGHT : uint32_t { + + CK_STATESAVE_LIGHTDATA = 0x00400000, // Save Color,Type,Attenuation,Range and cone + CK_STATESAVE_LIGHTDATA2 = 0x00800000, // Reserved for future use + CK_STATESAVE_LIGHTRESERVED1 = 0x01000000, // Reserved for future use + CK_STATESAVE_LIGHTRESERVED2 = 0x02000000, // Reserved for future use + CK_STATESAVE_LIGHTRESERVED3 = 0x04000000, // Reserved for future use + CK_STATESAVE_LIGHTRESERVED4 = 0x08000000, // Reserved for future use + CK_STATESAVE_LIGHTONLY = 0x0FC00000, // Save only Light specific datas + CK_STATESAVE_LIGHTALL = 0x0FFFFFFF, // Save All datas for sub-classes +// Target Light +CK_STATESAVE_TLIGHTTARGET = 0x80000000, // Save Light Target +CK_STATESAVE_TLIGHTRESERVED0 = 0x10000000, // Reserved for future use +CK_STATESAVE_TLIGHTRESERVED1 = 0x20000000, // Reserved for future use +CK_STATESAVE_TLIGHTRESERVED2 = 0x40000000, // Reserved for future use +CK_STATESAVE_TLIGHTONLY = 0xF0000000, // Save only Target Light specific datas +CK_STATESAVE_TLIGHTALL = 0xFFFFFFFF // Save All datas for sub-classes + }; + + //-------------------------------------------------- + // Camera + enum class CK_STATESAVEFLAGS_CAMERA : uint32_t { + + CK_STATESAVE_CAMERAFOV = 0x00400000, // Save Camera Field of View + CK_STATESAVE_CAMERAPROJTYPE = 0x00800000, // Save Camera projection type + CK_STATESAVE_CAMERAOTHOZOOM = 0x01000000, // Save Camera orhographic zoom + CK_STATESAVE_CAMERAASPECT = 0x02000000, // Save Camera aspect ration + CK_STATESAVE_CAMERAPLANES = 0x04000000, // Save Camera near and far clip planes + CK_STATESAVE_CAMERARESERVED2 = 0x08000000, // Reserved for future use + CK_STATESAVE_CAMERAONLY = 0x0FC00000, // Save only camera specific datas + CK_STATESAVE_CAMERAALL = 0x0FFFFFFF, // Save All datas for sub-classes +// Target Camera +CK_STATESAVE_TCAMERATARGET = 0x10000000, // Save camera Target +CK_STATESAVE_TCAMERARESERVED1 = 0x20000000, // Reserved for future use +CK_STATESAVE_TCAMERARESERVED2 = 0x40000000, // Reserved for future use +CK_STATESAVE_TCAMERAONLY = 0x70000000, // Save only Target camera specific datas +CK_STATESAVE_TCAMERAALL = 0x7FFFFFFF // Save All datas for sub-classes + }; + + + //-------------------------------------------------- + // Sprite3D + enum class CK_STATESAVEFLAGS_SPRITE3D : uint32_t { + + CK_STATESAVE_SPRITE3DDATA = 0x00400000, // Save offset,mapping,size and material + CK_STATESAVE_SPRITE3DRESERVED0 = 0x00800000, // Reserved for future use + CK_STATESAVE_SPRITE3DRESERVED1 = 0x01000000, // Reserved for future use + CK_STATESAVE_SPRITE3DRESERVED2 = 0x02000000, // Reserved for future use + CK_STATESAVE_SPRITE3DRESERVED3 = 0x04000000, // Reserved for future use + CK_STATESAVE_SPRITE3DRESERVED4 = 0x08000000, // Reserved for future use + CK_STATESAVE_SPRITE3DONLY = 0x0FC00000, // Save only Sprite3D specific datas + CK_STATESAVE_SPRITE3DALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + //-------------------------------------------------- + // Object 3D + enum class CK_STATESAVEFLAGS_3DOBJECT : uint32_t { + + CK_STATESAVE_3DOBJECTATTRIBUTES = 0x00400000, // Obsolete + CK_STATESAVE_3DOBJECTRESERVED = 0x00800000, // Reserved for future use + CK_STATESAVE_3DOBJECTRONLY = 0x00C00000, // Save only 3dObject specific datas + CK_STATESAVE_3DOBJECTALL = 0x03FFFFFF // Save All datas for sub-classes + }; + + //-------------------------------------------------- + // BodyPart + enum class CK_STATESAVEFLAGS_BODYPART : uint32_t { + + CK_STATESAVE_BODYPARTROTJOINT = 0x01000000, // Save rotation joint data + CK_STATESAVE_BODYPARTPOSJOINT = 0x02000000, // Save position joint data + CK_STATESAVE_BODYPARTCHARACTER = 0x04000000, // Save character owning this bodypart + CK_STATESAVE_BODYPARTRESERVED1 = 0x08000000, // Reserved for future use + CK_STATESAVE_BODYPARTRESERVED2 = 0x10000000, // Reserved for future use + CK_STATESAVE_BODYPARTRESERVED3 = 0x20000000, // Reserved for future use + CK_STATESAVE_BODYPARTRESERVED4 = 0x40000000, // Reserved for future use + CK_STATESAVE_BODYPARTONLY = 0x7F000000, // Save only bodypart specific datas + CK_STATESAVE_BODYPARTALL = 0x7FFFFFFF // Save All datas for sub-classes + }; + + //-------------------------------------------------- + // Character + enum class CK_STATESAVEFLAGS_CHARACTER : uint32_t { + + CK_STATESAVE_CHARACTERBODYPARTS = 0x00400000, // Obsolete + CK_STATESAVE_CHARACTERKINECHAINS = 0x00800000, // Obsolete + CK_STATESAVE_CHARACTERANIMATIONS = 0x01000000, // Obsolete + CK_STATESAVE_CHARACTERROOT = 0x02000000, // Obsolete + CK_STATESAVE_CHARACTERSAVEANIMS = 0x04000000, // Save current and next active animations + CK_STATESAVE_CHARACTERSAVECHAINS = 0x08000000, // Obsolete + CK_STATESAVE_CHARACTERSAVEPARTS = 0x10000000, // Save sub bodyparts and sub-bodyparts data (saved with flag :CK_STATESAVE_BODYPARTALL) + CK_STATESAVE_CHARACTERFLOORREF = 0x20000000, // Save Character floor reference object + CK_STATESAVE_CHARACTERRESERVED2 = 0x40000000, // Reserved for future use + CK_STATESAVE_CHARACTERRESERVED3 = 0x80000000, // Reserved for future use + CK_STATESAVE_CHARACTERONLY = 0xFFC00000, // Save only character specific datas + CK_STATESAVE_CHARACTERALL = 0xFFFFFFFF // Save All datas for sub-classes + }; + + //-------------------------------------------------- + // CURVE + // && Curve Point + enum class CK_STATESAVEFLAGS_CURVE : uint32_t { + + CK_STATESAVE_CURVEFITCOEFF = 0x00400000, // Save fitting coef + CK_STATESAVE_CURVECONTROLPOINT = 0x00800000, // Save list of control points + CK_STATESAVE_CURVESTEPS = 0x01000000, // Save number of step setting + CK_STATESAVE_CURVEOPEN = 0x02000000, // Save Open/Close flag + CK_STATESAVE_CURVERESERVED1 = 0x04000000, // Reserved for future use + CK_STATESAVE_CURVERESERVED2 = 0x08000000, // Reserved for future use +// Control points +CK_STATESAVE_CURVEPOINTDEFAULTDATA = 0x10000000, // Save Control point setting and position +CK_STATESAVE_CURVEPOINTTCB = 0x20000000, // Save Control point tcb settings +CK_STATESAVE_CURVEPOINTTANGENTS = 0x40000000, // Save Control point tangents +CK_STATESAVE_CURVEPOINTCURVEPOS = 0x80000000, // Save Control point position in curve +CK_STATESAVE_CURVESAVEPOINTS = 0xFF000000, // Save control points data + +CK_STATESAVE_CURVEONLY = 0xFFC00000, // Save only curve specific data +CK_STATESAVE_CURVEALL = 0xFFFFFFFF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // 2dEntity + enum class CK_STATESAVEFLAGS_2DENTITY : uint32_t { + + CK_STATESAVE_2DENTITYSRCSIZE = 0x00001000, // Save source size + CK_STATESAVE_2DENTITYSIZE = 0x00002000, // Save size + CK_STATESAVE_2DENTITYFLAGS = 0x00004000, // Save Flags + CK_STATESAVE_2DENTITYPOS = 0x00008000, // Save position + CK_STATESAVE_2DENTITYZORDER = 0x00100000, // Save Z order + CK_STATESAVE_2DENTITYONLY = 0x0010F000, // Save only 2dEntity specific data + CK_STATESAVE_2DENTITYMATERIAL = 0x00200000, // Save Material + CK_STATESAVE_2DENTITYHIERARCHY = 0x00400000, // Save Material + CK_STATESAVE_2DENTITYALL = 0x0070FFFF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // Sprite + enum class CK_STATESAVEFLAGS_SPRITE : uint32_t { + + CK_STATESAVE_SPRITECURRENTIMAGE = 0x00010000, // Save current image + CK_STATESAVE_SPRITETRANSPARENT = 0x00020000, // Save transparency settings + CK_STATESAVE_SPRITEBITMAPS = 0x00040000, // Obsolete + CK_STATESAVE_SPRITESHARED = 0x00080000, // Save shared sprite + CK_STATESAVE_SPRITEDONOTUSE = 0x00100000, // Reseved by CK_STATESAVEFLAGS_2DENTITY + CK_STATESAVE_SPRITEAVIFILENAME = 0x00200000, // Obsolete + CK_STATESAVE_SPRITEFILENAMES = 0x00400000, // Obsolete + CK_STATESAVE_SPRITECOMPRESSED = 0x00800000, // Obsolete + CK_STATESAVE_SPRITEREADER = 0x10000000, // Reserved for future use + CK_STATESAVE_SPRITEFORMAT = 0x20000000, // Reserved for future use + CK_STATESAVE_SPRITEVIDEOFORMAT = 0x40000000, // Video Format + CK_STATESAVE_SPRITESYSTEMCACHING = 0x80000000, // System Memory Caching + CK_STATESAVE_SPRITERENDEROPTIONS = 0x80800000, // Render options if any... + CK_STATESAVE_SPRITEONLY = 0xF0EF0000, // Save only sprite specific data + CK_STATESAVE_SPRITEALL = 0x70FFFFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // Sprite Text + enum class CK_STATESAVEFLAGS_SPRITETEXT : uint32_t { + + CK_STATESAVE_SPRITETEXT = 0x01000000, // Save text + CK_STATESAVE_SPRITEFONT = 0x02000000, // Save font settings + CK_STATESAVE_SPRITETEXTCOLOR = 0x04000000, // Save text color + CK_STATESAVE_SPRITETEXTRESERVED = 0x08000000, // Reserved for future use + CK_STATESAVE_SPRITETEXTDOTNOTUSE = 0x10000000, // Reserved by CK_STATESAVE_SPRITEREADER + CK_STATESAVE_SPRITETEXTDONOTUSED2 = 0x20000000, // Reserved by CK_STATESAVE_SPRITEFORMAT + CK_STATESAVE_SPRITETEXTONLY = 0x0F000000, // Save only SpriteText specific data + CK_STATESAVE_SPRITETEXTALL = 0x3FFFFFFF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // Sound + enum class CK_STATESAVEFLAGS_SOUND : uint32_t { + + CK_STATESAVE_SOUNDFILENAME = 0x00001000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED1 = 0x00002000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED2 = 0x00004000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED3 = 0x00008000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED4 = 0x00010000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED5 = 0x00020000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED6 = 0x00040000, // Reserved for future use + CK_STATESAVE_SOUNDRESERVED7 = 0x00080000, // Reserved for future use + CK_STATESAVE_SOUNDONLY = 0x000FF000, // Save only Sound specific data + CK_STATESAVE_SOUNDALL = 0x000FFFFF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // Wave Sound + enum class CK_STATESAVEFLAGS_WAVSOUND : uint32_t { + + CK_STATESAVE_WAVSOUNDFILE = 0x00100000, // Save sound filename + CK_STATESAVE_WAVSOUNDDATA = 0x00200000, // Obsolete + CK_STATESAVE_WAVSOUNDDATA2 = 0x00400000, // Save sound properties (3D/2D,pitch,gain,streaming,loop,etc..) + CK_STATESAVE_WAVSOUNDDURATION = 0x00800000, // Sound Length (in case it cannot be calculated latter) + CK_STATESAVE_WAVSOUNDRESERVED4 = 0x01000000, // Reserved for future use + CK_STATESAVE_WAVSOUNDRESERVED5 = 0x02000000, // Reserved for future use + CK_STATESAVE_WAVSOUNDRESERVED6 = 0x04000000, // Reserved for future use + CK_STATESAVE_WAVSOUNDRESERVED7 = 0x08000000, // Reserved for future use + CK_STATESAVE_WAVSOUNDONLY = 0x0FF00000, // Save All datas for sub-classes + CK_STATESAVE_WAVSOUNDALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // Wave Sound + enum class CK_STATESAVEFLAGS_MIDISOUND : uint32_t { + + CK_STATESAVE_MIDISOUNDFILE = 0x00100000, // Save sound filename + CK_STATESAVE_MIDISOUNDDATA = 0x00200000, // Save midi data + CK_STATESAVE_MIDISOUNDRESERVED2 = 0x00400000, // Reserved for future use + CK_STATESAVE_MIDISOUNDRESERVED3 = 0x00800000, // Reserved for future use + CK_STATESAVE_MIDISOUNDRESERVED4 = 0x01000000, // Reserved for future use + CK_STATESAVE_MIDISOUNDRESERVED5 = 0x02000000, // Reserved for future use + CK_STATESAVE_MIDISOUNDRESERVED6 = 0x04000000, // Reserved for future use + CK_STATESAVE_MIDISOUNDRESERVED7 = 0x08000000, // Reserved for future use + CK_STATESAVE_MIDISOUNDONLY = 0x0FF00000, + CK_STATESAVE_MIDISOUNDALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // Place + enum class CK_STATESAVEFLAGS_PLACE : uint32_t { + + CK_STATESAVE_PLACEPORTALS = 0x00001000, // Save level using the place + CK_STATESAVE_PLACECAMERA = 0x00002000, // Save attached camera + CK_STATESAVE_PLACEREFERENCES = 0x00004000, // Save list of objects in the place + CK_STATESAVE_PLACELEVEL = 0x00008000, // Save level using the place + CK_STATESAVE_PLACEALL = 0x0000FFFF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // Level + // CKSaveObjectState will not save any data + enum class CK_STATESAVEFLAGS_LEVEL : uint32_t { + + CK_STATESAVE_LEVELRESERVED0 = 0x00001000, // Reserved for future use + CK_STATESAVE_LEVELINACTIVEMAN = 0x00002000, // Reserved for future use + CK_STATESAVE_LEVELDUPLICATEMAN = 0x00004000, // Reserved for future use + CK_STATESAVE_LEVELDEFAULTDATA = 0x20000000, // Save Places,Scenes and Objects + CK_STATESAVE_LEVELSCENE = 0x80000000, // Default and active scene + CK_STATESAVE_LEVELALL = 0xFFFFFFFF // Save All datas for sub-classes + }; + + + + + //------------------------------------------------ + // GROUP + enum class CK_STATESAVEFLAGS_GROUP : uint32_t { + + CK_STATESAVE_GROUPDATA = 0x00001000, // Save list of objects in the group + CK_STATESAVE_GROUPRESERVED1 = 0x00002000, // Reserved for future use + CK_STATESAVE_GROUPRESERVED2 = 0x00004000, // Reserved for future use + CK_STATESAVE_GROUPRESERVED3 = 0x00008000, // Reserved for future use + CK_STATESAVE_GROUPRESERVED4 = 0x00010000, // Reserved for future use + CK_STATESAVE_GROUPRESERVED5 = 0x00020000, // Reserved for future use + CK_STATESAVE_GROUPRESERVED6 = 0x00040000, // Reserved for future use + CK_STATESAVE_GROUPRESERVED7 = 0x00080000, // Reserved for future use + CK_STATESAVE_GROUPALL = 0x000FFFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // MESH + // CKSaveOjectSave will save all data and does not take flags into account + enum class CK_STATESAVEFLAGS_MESH : uint32_t { + + CK_STATESAVE_MESHRESERVED0 = 0x00001000, // Reserved for future use + CK_STATESAVE_MESHFLAGS = 0x00002000, // Save flags + CK_STATESAVE_MESHCHANNELS = 0x00004000, // Save Channels + CK_STATESAVE_MESHFACECHANMASK = 0x00008000, // Save face channel Mask + CK_STATESAVE_MESHFACES = 0x00010000, // Save face data + CK_STATESAVE_MESHVERTICES = 0x00020000, // Save geometry + CK_STATESAVE_MESHLINES = 0x00040000, // Save line data + CK_STATESAVE_MESHWEIGHTS = 0x00080000, // Save Vertex Weight info + CK_STATESAVE_MESHMATERIALS = 0x00100000, // Reserved for future use + CK_STATESAVE_MESHRESERVED1 = 0x00200000, // Reserved for future use + CK_STATESAVE_MESHRESERVED2 = 0x00400000, // Reserved for future use + CK_STATESAVE_PROGRESSIVEMESH = 0x00800000, // Save All datas for sub-classes + CK_STATESAVE_MESHONLY = 0x00FFF000, // Save All datas for sub-classes + CK_STATESAVE_MESHALL = 0x00FFFFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // PATCH MESH + // CKSaveOjectSave will save all data and does not take flags into account + enum class CK_STATESAVEFLAGS_PATCHMESH : uint32_t { + + CK_STATESAVE_PATCHMESHDATA = 0x00800000, // Obsolete + CK_STATESAVE_PATCHMESHDATA2 = 0x01000000, // Obsolete + CK_STATESAVE_PATCHMESHSMOOTH = 0x02000000, // Obsolete + CK_STATESAVE_PATCHMESHMATERIALS = 0x04000000, // Obsolete + CK_STATESAVE_PATCHMESHDATA3 = 0x08000000, // Save Patch Data + CK_STATESAVE_PATCHMESHONLY = 0x0FF00000, // Save All datas for sub-classes + CK_STATESAVE_PATCHMESHALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + //------------------------------------------------- + // Material + enum class CK_STATESAVEFLAGS_MATERIAL : uint32_t { + + CK_STATESAVE_MATDATA = 0x00001000, // Save colors,blending modes,shade modes,fill modes etc... + CK_STATESAVE_MATDATA2 = 0x00002000, // Additional texture objects... + CK_STATESAVE_MATDATA3 = 0x00004000, // Effect Alone + CK_STATESAVE_MATDATA4 = 0x00008000, // none + CK_STATESAVE_MATDATA5 = 0x00010000, // Effect + parameter + CK_STATESAVE_MATRESERVED5 = 0x00020000, // Reserved for future use + CK_STATESAVE_MATRESERVED6 = 0x00040000, // Reserved for future use + CK_STATESAVE_MATRESERVED7 = 0x00080000, // Reserved for future use + CK_STATESAVE_MATERIALONLY = 0x000FF000, // Save All datas for sub-classes + CK_STATESAVE_MATERIALALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // Texture + // CKSaveOjectSave will save all relevant data and does not take flags into account + enum class CK_STATESAVEFLAGS_TEXTURE : uint32_t { + + CK_STATESAVE_TEXAVIFILENAME = 0x00001000, // Save movie file name + CK_STATESAVE_TEXCURRENTIMAGE = 0x00002000, // Save current slot + CK_STATESAVE_TEXBITMAPS = 0x00004000, // Obsolete + CK_STATESAVE_TEXTRANSPARENT = 0x00008000, // Save transparency data + CK_STATESAVE_TEXFILENAMES = 0x00010000, // Save texture slot filenames + CK_STATESAVE_TEXCOMPRESSED = 0x00020000, // Save raw texture data + CK_STATESAVE_TEXVIDEOFORMAT = 0x00040000, // Save chosen video format + CK_STATESAVE_TEXSAVEFORMAT = 0x00080000, // Save chosen save format + CK_STATESAVE_TEXREADER = 0x00100000, // Save texture data using a specific BitmapReader + CK_STATESAVE_PICKTHRESHOLD = 0x00200000, // Save pick threshold + CK_STATESAVE_USERMIPMAP = 0x00400000, // User mipmap levels + CK_STATESAVE_TEXSYSTEMCACHING = 0x00800000, // System Memory Caching + CK_STATESAVE_OLDTEXONLY = 0x002FF000, // Kept for compatibility + CK_STATESAVE_TEXONLY = 0x00FFF000, // Save Only Texture Data (Dot NOT MODIFY ! Texture loading/saving relies on this value) + CK_STATESAVE_TEXALL = 0x002FFFFF // Save All datas for sub-classes + }; + + + //--------------------------------------------------- + // 2d CURVE + // && 2d Curve Point + enum class CK_STATESAVEFLAGS_2DCURVE : uint32_t { + + CK_STATESAVE_2DCURVERESERVED0 = 0x00000010, // Reserved for future use + CK_STATESAVE_2DCURVERESERVED4 = 0x00000020, // Reserved for future use + CK_STATESAVE_2DCURVEFITCOEFF = 0x00000040, // Obsolete + CK_STATESAVE_2DCURVECONTROLPOINT = 0x00000080, // Obsolete + CK_STATESAVE_2DCURVENEWDATA = 0x00000100, // Save All relevant data + CK_STATESAVE_2DCURVERESERVED2 = 0x00000200, // Obsolete + CK_STATESAVE_2DCURVERESERVED3 = 0x00000400, // Obsolete + CK_STATESAVE_2DCURVEPOINTTCB = 0x00000800, // Obsolete + CK_STATESAVE_2DCURVEPOINTTANGENTS = 0x00001000, // Obsolete + CK_STATESAVE_2DCURVEPOINT2DCURVEPOS = 0x00002000, // Obsolete + CK_STATESAVE_2DCURVEPOINTDEFAULTDATA = 0x00004000, // Obsolete + CK_STATESAVE_2DCURVEPOINTNEWDATA = 0x00008000, // Save All relevant data + CK_STATESAVE_2DCURVEPOINTRESERVED1 = 0x00010000, // Reserved for future use + CK_STATESAVE_2DCURVEPOINTRESERVED2 = 0x00020000, // Reserved for future use + CK_STATESAVE_2DCURVESAVEPOINTS = 0x0003F800, // Obsolete + CK_STATESAVE_2DCURVEALL = 0x0007FFFF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // Kinematic Chain + + enum class CK_STATESAVEFLAGS_KINEMATICCHAIN : uint32_t { + + CK_STATESAVE_KINEMATICCHAINDATA = 0x00000010, // Save chain data + CK_STATESAVE_KINEMATICCHAINRESERVED1 = 0x00000020, // Reserved for future use + CK_STATESAVE_KINEMATICCHAINRESERVED2 = 0x00000040, // Reserved for future use + CK_STATESAVE_KINEMATICCHAINRESERVED3 = 0x00000080, // Reserved for future use + CK_STATESAVE_KINEMATICCHAINALL = 0x000000FF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // Animation + enum class CK_STATESAVEFLAGS_ANIMATION : uint32_t { + + CK_STATESAVE_ANIMATIONDATA = 0x00000010, // Save Flags & Framerate data + CK_STATESAVE_ANIMATIONRESERVED1 = 0x00000020, // Reserved for future use + CK_STATESAVE_ANIMATIONLENGTH = 0x00000040, // Save animation Length + CK_STATESAVE_ANIMATIONBODYPARTS = 0x00000080, // Save root & list of bodypart + CK_STATESAVE_ANIMATIONCHARACTER = 0x00000100, // Save character + CK_STATESAVE_ANIMATIONCURRENTSTEP = 0x00000200, // Save current step + CK_STATESAVE_ANIMATIONRESERVED5 = 0x00000400, // Reserved for future use + CK_STATESAVE_ANIMATIONRESERVED6 = 0x00000800, // Reserved for future use + CK_STATESAVE_ANIMATIONALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // Keyed Anim + enum class CK_STATESAVEFLAGS_KEYEDANIMATION : uint32_t { + + CK_STATESAVE_KEYEDANIMANIMLIST = 0x00001000, // Save list of object animations + CK_STATESAVE_KEYEDANIMLENGTH = 0x00002000, // Obsolete + CK_STATESAVE_KEYEDANIMPOSKEYS = 0x00004000, // Obsolete + CK_STATESAVE_KEYEDANIMROTKEYS = 0x00008000, // Obsolete + CK_STATESAVE_KEYEDANIMMORPHKEYS = 0x00010000, // Obsolete + CK_STATESAVE_KEYEDANIMSCLKEYS = 0x00020000, // Obsolete + CK_STATESAVE_KEYEDANIMFLAGS = 0x00040000, // Obsolete + CK_STATESAVE_KEYEDANIMENTITY = 0x00080000, // Obsolete + CK_STATESAVE_KEYEDANIMMERGE = 0x00100000, // Save merged animations + CK_STATESAVE_KEYEDANIMSUBANIMS = 0x00200000, // Save object animations data (using same flags than CKSaveObjectState) + CK_STATESAVE_KEYEDANIMRESERVED0 = 0x00400000, // Reserved for future use + CK_STATESAVE_KEYEDANIMRESERVED1 = 0x00800000, // Reserved for future use + CK_STATESAVE_KEYEDANIMRESERVED2 = 0x01000000, // Reserved for future use + CK_STATESAVE_KEYEDANIMRESERVED3 = 0x02000000 // Reserved for future use + }; + + + //--------------------------------------------------- + // Object Animation + // CKSaveOjectSave will save all relevant data and does not take flags into account + enum class CK_STATESAVEFLAGS_OBJECTANIMATION : uint32_t { + + CK_STATESAVE_OBJANIMNEWDATA = 0x00001000, // Save all relevant data + CK_STATESAVE_OBJANIMLENGTH = 0x00002000, // Not used + CK_STATESAVE_OBJANIMPOSKEYS = 0x00004000, // Not used + CK_STATESAVE_OBJANIMROTKEYS = 0x00008000, // Not used + CK_STATESAVE_OBJANIMMORPHKEYS = 0x00010000, // Not used + CK_STATESAVE_OBJANIMSCLKEYS = 0x00020000, // Not used + CK_STATESAVE_OBJANIMFLAGS = 0x00040000, // Not used + CK_STATESAVE_OBJANIMENTITY = 0x00080000, // Not used + CK_STATESAVE_OBJANIMMERGE = 0x00100000, // Not used + CK_STATESAVE_OBJANIMMORPHKEYS2 = 0x00200000, // Not used + CK_STATESAVE_OBJANIMNEWSAVE1 = 0x00400000, // Not used + CK_STATESAVE_OBJANIMMORPHNORMALS = 0x00800000, // Not used (Virtools 1.1) + CK_STATESAVE_OBJANIMMORPHCOMP = 0x01000000, // Not used (Virtools 1.1) + CK_STATESAVE_OBJANIMSHARED = 0x02000000, // Save Data for a shared animation + CK_STATESAVE_OBJANIMCONTROLLERS = 0x04000000, // (Virtools 1.5) Save All Controller information + CK_STATESAVE_OBJANIMONLY = 0x07FFF000, + CK_STATESAVE_OBJANIMALL = 0x07FFFFFF, + CK_STATESAVE_KEYEDANIMONLY = 0x03FFF000, // Save All datas for sub-classes + CK_STATESAVE_KEYEDANIMALL = 0x03FFFFFF // Save All datas for sub-classes + }; + + + //--------------------------------------------------- + // IK Animation + enum class CK_STATESAVEFLAGS_IKANIMATION : uint32_t { + + CK_STATESAVE_IKANIMATIONDATA = 0x00001000, // Save IK data + CK_STATESAVE_IKANIMATIONRESERVED2 = 0x00002000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED3 = 0x00004000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED4 = 0x00008000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED5 = 0x00010000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED6 = 0x00020000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED7 = 0x00040000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED8 = 0x00100000, // Reserved for future use + CK_STATESAVE_IKANIMATIONRESERVED9 = 0x00200000, // Reserved for future use + CK_STATESAVE_IKANIMATIONALL = 0x003FFFFF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // BehaviorLink + enum class CK_STATESAVEFLAGS_BEHAV_LINK : uint32_t { + + CK_STATESAVE_BEHAV_LINK_CURDELAY = 0x00000004, // Obsolete + CK_STATESAVE_BEHAV_LINK_IOS = 0x00000008, // Obsolete + CK_STATESAVE_BEHAV_LINK_DELAY = 0x00000010, // Obsolete + CK_STATESAVE_BEHAV_LINK_NEWDATA = 0x00000020, // Save all relevant data (In,Out,Activation delay) + CK_STATESAVE_BEHAV_LINKRESERVED5 = 0x00000040, // Reserved for future use + CK_STATESAVE_BEHAV_LINKRESERVED6 = 0x00000080, // Reserved for future use + CK_STATESAVE_BEHAV_LINKONLY = 0x000000F0, // + CK_STATESAVE_BEHAV_LINKALL = 0x000000FF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // BehaviorIO + enum class CK_STATESAVEFLAGS_BEHAV_IO : uint32_t { + + CK_STATESAVE_BEHAV_IOFLAGS = 0x00000008, // Save IO flags + CK_STATESAVE_BEHAV_IORESERVED3 = 0x00000010, // Reserved for future use + CK_STATESAVE_BEHAV_IORESERVED4 = 0x00000020, // Reserved for future use + CK_STATESAVE_BEHAV_IORESERVED5 = 0x00000040, // Reserved for future use + CK_STATESAVE_BEHAV_IORESERVED6 = 0x00000080, // Reserved for future use + CK_STATESAVE_BEHAVIOONLY = 0x000000F0, // + CK_STATESAVE_BEHAVIOALL = 0x000000FF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // BehaviorPrototype + enum class CK_STATESAVEFLAGS_PROTOTYPE : uint32_t { + + CK_STATESAVE_PROTORESERVED0 = 0x00000010, // Reserved for future use + CK_STATESAVE_PROTORESERVED1 = 0x00000020, // Reserved for future use + CK_STATESAVE_PROTOFLAGS = 0x00000040, // Save Flags + CK_STATESAVE_PROTOSUBPROTOS = 0x00000080, // Save sub prototypes + CK_STATESAVE_PROTOLINKS = 0x00000100, // Save links + CK_STATESAVE_PROTOBEHAVFLAG = 0x00000200, // Save behavior flags + CK_STATESAVE_PROTOGUID = 0x00000400, // Save GUID + CK_STATESAVE_PROTOINPUTS = 0x00000800, // Save inputs + CK_STATESAVE_PROTOOUTPUTS = 0x00001000, // Save outputs + CK_STATESAVE_PROTOINPARAMS = 0x00002000, // Save input parameters + CK_STATESAVE_PROTOOUTPARAMS = 0x00004000, // Save output parameters + CK_STATESAVE_PROTOLOCALPARAMS = 0x00008000, // Save local parameters + CK_STATESAVE_PROTOOPERATIONS = 0x00010000, // Save parameter operations + CK_STATESAVE_PROTOPARAMETERLINKS = 0x00020000, // Save parameter links + CK_STATESAVE_PROTOAPPLYTO = 0x00040000, // Save ClassID of object to which it applies + CK_STATESAVE_PROTORESERVED14 = 0x00080000, // Reserved for future use + CK_STATESAVE_PROTOALL = 0x000FFFFF // Save All datas for sub-classes + }; + + + //--------------------------------------------------- + // Behavior + enum class CK_STATESAVEFLAGS_BEHAVIOR : uint32_t { + + CK_STATESAVE_BEHAVIORRESERVED0 = 0x00000010, // Reserved for internal use + CK_STATESAVE_BEHAVIORNEWDATA = 0x00000020, // not used + CK_STATESAVE_BEHAVIORFLAGS = 0x00000040, // not used + CK_STATESAVE_BEHAVIORCOMPATIBLECID = 0x00000080, // not used + CK_STATESAVE_BEHAVIORSUBBEHAV = 0x00000100, // Save Sub-Behaviors + CK_STATESAVE_BEHAVIORINPARAMS = 0x00000200, // not used + CK_STATESAVE_BEHAVIOROUTPARAMS = 0x00000400, // not used + CK_STATESAVE_BEHAVIORINPUTS = 0x00000800, // not used + CK_STATESAVE_BEHAVIOROUTPUTS = 0x00001000, // not used + CK_STATESAVE_BEHAVIORINFO = 0x00002000, // not used + CK_STATESAVE_BEHAVIOROPERATIONS = 0x00004000, // not used + CK_STATESAVE_BEHAVIORTYPE = 0x00008000, // not used + CK_STATESAVE_BEHAVIOROWNER = 0x00010000, // not used + CK_STATESAVE_BEHAVIORLOCALPARAMS = 0x00020000, // Save local parameters + CK_STATESAVE_BEHAVIORPROTOGUID = 0x00040000, // not used + CK_STATESAVE_BEHAVIORSUBLINKS = 0x00080000, // not used + CK_STATESAVE_BEHAVIORACTIVESUBLINKS = 0x00100000, // not used + CK_STATESAVE_BEHAVIORSINGLEACTIVITY = 0x00200000, // SINGLE ACTIVITY + CK_STATESAVE_BEHAVIORSCRIPTDATA = 0x00400000, // not used + CK_STATESAVE_BEHAVIORPRIORITY = 0x00800000, // not used + CK_STATESAVE_BEHAVIORTARGET = 0x01000000, // not used + CK_STATESAVE_BEHAVIORONLY = 0x01FFFFF0, + CK_STATESAVE_BEHAVIORALL = 0x01FFFFFF // Save All datas for sub-classes + }; + + + + + //--------------------------------------------------- + // SCENE + // CKSaveOjectSave will save all relevant data and does not take flags into account + enum class CK_STATESAVEFLAGS_SCENE : uint32_t { + + CK_STATESAVE_SCENERESERVED0 = 0x00001000, // Reserved for future use + CK_STATESAVE_SCENERESERVED8 = 0x00002000, // Reserved for future use + CK_STATESAVE_SCENEFLAGS = 0x00004000, + CK_STATESAVE_SCENELEVEL = 0x00008000, + CK_STATESAVE_SCENEOBJECTS = 0x00010000, + CK_STATESAVE_SCENENEWDATA = 0x00020000, // every object description and initial conditions + CK_STATESAVE_SCENELAUNCHED = 0x00040000, // Scene was already launched once + CK_STATESAVE_SCENERENDERSETTINGS = 0x00080000, // Background Color, Fog Color etc.. + CK_STATESAVE_SCENERESERVED1 = 0x00100000, // Reserved for future use + CK_STATESAVE_SCENERESERVED2 = 0x00200000, // Reserved for future use + CK_STATESAVE_SCENERESERVED3 = 0x00400000, // Reserved for future use + CK_STATESAVE_SCENERESERVED4 = 0x00800000, // Reserved for future use + CK_STATESAVE_SCENERESERVED5 = 0x01000000, // Reserved for future use + CK_STATESAVE_SCENERESERVED12 = 0x02000000, // Reserved for future use + CK_STATESAVE_SCENERESERVED13 = 0x04000000, // Reserved for future use + CK_STATESAVE_SCENERESERVED14 = 0x08000000, // Reserved for future use + CK_STATESAVE_SCENEALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + + //--------------------------------------------------- + // ParameterIn + enum class CK_STATESAVEFLAGS_PARAMETERIN : uint32_t { + + CK_STATESAVE_PARAMETERIN_RESERVED4 = 0x00000010, // Reserved for future use + CK_STATESAVE_PARAMETERIN_RESERVED0 = 0x00000020, // Reserved for future use + CK_STATESAVE_PARAMETERIN_RESERVED1 = 0x00000040, // Reserved for future use + CK_STATESAVE_PARAMETERIN_OWNER = 0x00000080, // Obsolete + CK_STATESAVE_PARAMETERIN_INSHARED = 0x00000100, // Obsolete + CK_STATESAVE_PARAMETERIN_OUTSOURCE = 0x00000200, // Obsolete + CK_STATESAVE_PARAMETERIN_DEFAULTDATA = 0x00000400, // Obsolete + CK_STATESAVE_PARAMETERIN_DATASHARED = 0x00000800, // Save reference to shared inparameter + CK_STATESAVE_PARAMETERIN_DATASOURCE = 0x00001000, // Save reference to source outparameter + CK_STATESAVE_PARAMETERIN_DISABLED = 0x00002000, // The parameter was disabled + CK_STATESAVE_PARAMETERIN_ALL = 0x0000FFFF // Save All datas for sub-classes + }; + + //--------------------------------------------------- + // ParameterLocal et ParameterOut + enum class CK_STATESAVEFLAGS_PARAMETEROUT : uint32_t { + + CK_STATESAVE_PARAMETEROUT_RESERVED0 = 0x00000010, // Reserved for future use + CK_STATESAVE_PARAMETEROUT_DESTINATIONS = 0x00000020, // Save destinations + CK_STATESAVE_PARAMETEROUT_VAL = 0x00000040, // Save value + CK_STATESAVE_PARAMETEROUT_OWNER = 0x00000080, // Save Owner + CK_STATESAVE_PARAMETEROUT_MYSELF = 0x00000200, // + CK_STATESAVE_PARAMETEROUT_ISSETTING = 0x00000400, // Reserved for future use + CK_STATESAVE_PARAMETEROUT_ALL = 0x0000FFFF // Save All datas for sub-classes + }; + + + //--------------------------------------------------- + // Parameter Operation + + enum class CK_STATESAVEFLAGS_OPERATION : uint32_t { + + CK_STATESAVE_OPERATIONRESERVED0 = 0x00000010, // Reserved for future use + CK_STATESAVE_OPERATIONRESERVED1 = 0x00000020, // Reserved for future use + CK_STATESAVE_OPERATIONINPUTS = 0x00000040, + CK_STATESAVE_OPERATIONOUTPUT = 0x00000080, + CK_STATESAVE_OPERATIONOP = 0x00000100, + CK_STATESAVE_OPERATIONDEFAULTDATA = 0x00000200, + CK_STATESAVE_OPERATIONNEWDATA = 0x00000400, + CK_STATESAVE_OPERATIONALL = 0x000007FF // Save All datas for sub-classes + }; + + + //--------------------------------------------------- + // Synchro Object + // CKSaveOjectSave will save all relevant data and does not take flags into account + enum class CK_STATESAVEFLAGS_SYNCHRO : uint32_t { + + CK_STATESAVE_SYNCHRODATA = 0x00000010, // Save data + CK_STATESAVE_SYNCHRORESERVED0 = 0x00000040, // Reserved for future use + CK_STATESAVE_SYNCHRORESERVED1 = 0x00000080, // Reserved for future use + CK_STATESAVE_SYNCHRORESERVED2 = 0x00000100, // Reserved for future use + CK_STATESAVE_SYNCHRORESERVED3 = 0x00000200, // Reserved for future use + CK_STATESAVE_SYNCHRONALL = 0x000003FF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // Grid + enum class CK_STATESAVEFLAGS_GRID : uint32_t { + + CK_STATESAVE_GRIDDATA = 0x00400000, // Save Grid Data + CK_STATESAVE_GRIDRESERVED0 = 0x00800000, // Reserved for future use + CK_STATESAVE_GRIDRESERVED1 = 0x01000000, // Reserved for future use + CK_STATESAVE_GRIDRESERVED2 = 0x02000000, // Reserved for future use + CK_STATESAVE_GRIDRESERVED3 = 0x04000000, // Reserved for future use + CK_STATESAVE_GRIDRESERVED4 = 0x08000000, // Reserved for future use + CK_STATESAVE_GRIDONLY = 0x0FC00000, // + CK_STATESAVE_GRIDALL = 0x0FFFFFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // Layer (For Grids) + enum class CK_STATESAVEFLAGS_LAYER : uint32_t { + + CK_STATESAVE_LAYERDATA = 0x00000010, // Save Layer Data + CK_STATESAVE_LAYERRESERVED0 = 0x00800020, // Reserved for future use + CK_STATESAVE_LAYERRESERVED1 = 0x00000040, // Reserved for future use + CK_STATESAVE_LAYERRESERVED2 = 0x00000080, // Reserved for future use + CK_STATESAVE_LAYERRESERVED3 = 0x00000100, // Reserved for future use + CK_STATESAVE_LAYERRESERVED4 = 0x00000200, // Reserved for future use + CK_STATESAVE_LAYERONLY = 0x000003F0, // + CK_STATESAVE_LAYERALL = 0x000003FF // Save All datas for sub-classes + }; + + //------------------------------------------------ + // DataArray + // CKSaveOjectSave will save all relevant data and does not take flags into account + enum class CK_STATESAVEFLAGS_DATAARRAY : uint32_t { + + CK_STATESAVE_DATAARRAYFORMAT = 0x00001000, // Save format + CK_STATESAVE_DATAARRAYDATA = 0x00002000, // Save array data + CK_STATESAVE_DATAARRAYMEMBERS = 0x00004000, // Save members + CK_STATESAVE_DATAARRAYALL = 0x0000FFFF // Save All datas for sub-classes + }; + + + //------------------------------------------------ + // SceneObjectDesc + enum class CK_STATESAVEFLAGS_SCENEOBJECTDESC : uint32_t { + + + CK_STATESAVE_SCENEOBJECTDESC = 0x00000010, + CK_STATESAVE_SCENEOBJECTRES1 = 0x00000020, // Reserved for future use + CK_STATESAVE_SCENEOBJECTRES2 = 0x00000040, // Reserved for future use + CK_STATESAVE_SCENEOBJECTRES3 = 0x00000080, // Reserved for future use + CK_STATESAVE_SCENEOBJECTDESCALL = 0x000000FF // Save All datas for sub-classes + + }; + + +} \ No newline at end of file diff --git a/LibCmo/CKManagerImplements/CKBaseManager.cpp b/LibCmo/CKManagerImplements/CKBaseManager.cpp index b4ca5c9..c0555e2 100644 --- a/LibCmo/CKManagerImplements/CKBaseManager.cpp +++ b/LibCmo/CKManagerImplements/CKBaseManager.cpp @@ -9,6 +9,13 @@ namespace LibCmo::CK2::CKManagerImplements { } + CKERROR CKBaseManager::LoadData(CKStateChunk* statechunk, CKFileData::ShallowDocument* doc) { + return CKERROR::CKERR_OK; + } + CKStateChunk* CKBaseManager::SaveData(CKFileData::ShallowDocument* doc) { + return nullptr; + } + CKAttributeManager::CKAttributeManager(CKMinContext* ctx, CK_ID ckid) : CKBaseManager(ctx, ckid) { diff --git a/LibCmo/CKObjectImplements/CKObject.cpp b/LibCmo/CKObjectImplements/CKObject.cpp index 302f385..b8938d5 100644 --- a/LibCmo/CKObjectImplements/CKObject.cpp +++ b/LibCmo/CKObjectImplements/CKObject.cpp @@ -1,4 +1,7 @@ #include "../CKObjects.hpp" +#include "../CKStateChunk.hpp" +#include "../CKIdentifiers.hpp" +#include "../VTUtils.hpp" namespace LibCmo::CK2::CKObjectImplements { @@ -14,6 +17,32 @@ namespace LibCmo::CK2::CKObjectImplements { } CKERROR CKObject::Load(CKStateChunk* chunk, const CKFileData::ShallowDocument* doc) { + if (chunk->SeekIdentifier(Identifiers::CK_STATESAVEFLAGS_OBJECT::CK_STATESAVE_OBJECTHIDDEN)) { + EnumsHelper::FlagEnumRm(this->m_ObjectFlags, + { CK_OBJECT_FLAGS::CK_OBJECT_VISIBLE, + CK_OBJECT_FLAGS::CK_OBJECT_HIERACHICALHIDE } + ); + } else { + if (chunk->SeekIdentifier(Identifiers::CK_STATESAVEFLAGS_OBJECT::CK_STATESAVE_OBJECTHIERAHIDDEN)) { + // != 0 + EnumsHelper::FlagEnumRm(this->m_ObjectFlags, + { CK_OBJECT_FLAGS::CK_OBJECT_VISIBLE, } + ); + EnumsHelper::FlagEnumAdd(this->m_ObjectFlags, + { CK_OBJECT_FLAGS::CK_OBJECT_HIERACHICALHIDE, } + ); + + } else { + // == 0 + EnumsHelper::FlagEnumAdd(this->m_ObjectFlags, + { CK_OBJECT_FLAGS::CK_OBJECT_VISIBLE, } + ); + EnumsHelper::FlagEnumRm(this->m_ObjectFlags, + { CK_OBJECT_FLAGS::CK_OBJECT_HIERACHICALHIDE, } + ); + } + } + return CKERROR::CKERR_OK; } CKStateChunk* CKObject::Save(CKFileData::ShallowDocument* doc) { diff --git a/LibCmo/CKObjects.hpp b/LibCmo/CKObjects.hpp index 2d31279..734629d 100644 --- a/LibCmo/CKObjects.hpp +++ b/LibCmo/CKObjects.hpp @@ -6,6 +6,12 @@ namespace LibCmo::CK2::CKObjectImplements { class CKObject { + protected: + CK_ID m_ID; + std::string m_Name; + CK_OBJECT_FLAGS m_ObjectFlags; + CKMinContext* m_Context; + public: CKObject(CKMinContext* ctx, CK_ID ckid, CKSTRING name); CKObject(const CKObject&) = delete; @@ -13,7 +19,7 @@ namespace LibCmo::CK2::CKObjectImplements { virtual ~CKObject(); CK_ID GetID(void) { return this->m_ID; } - CKSTRING GetName(void) { (this->m_Name.empty()) ? (nullptr) : (this->m_Name.c_str()); } + CKSTRING GetName(void) { return (this->m_Name.empty() ? nullptr : this->m_Name.c_str()); } void SetName(CKSTRING u8_name) { this->m_Name = (u8_name == nullptr ? "" : u8_name); } CK_OBJECT_FLAGS GetObjectFlags(void) { return this->m_ObjectFlags; } void SetObjectFlags(CK_OBJECT_FLAGS flags) { this->m_ObjectFlags = flags; } @@ -21,11 +27,6 @@ namespace LibCmo::CK2::CKObjectImplements { virtual CK_CLASSID GetClassID(void) { return CK_CLASSID::CKCID_OBJECT; } virtual CKERROR Load(CKStateChunk* chunk, const CKFileData::ShallowDocument* doc); virtual CKStateChunk* Save(CKFileData::ShallowDocument* doc); - protected: - CK_ID m_ID; - std::string m_Name; - CK_OBJECT_FLAGS m_ObjectFlags; - CKMinContext* m_Context; }; class CKSceneObject : public CKObject { diff --git a/LibCmo/CKStateChunk.cpp b/LibCmo/CKStateChunk.cpp index 3255b17..8f367f2 100644 --- a/LibCmo/CKStateChunk.cpp +++ b/LibCmo/CKStateChunk.cpp @@ -344,12 +344,12 @@ namespace LibCmo::CK2 { this->m_Parser.m_Status = CKStateChunkStatus::READ; } - bool CKStateChunk::SeekIdentifier(CKDWORD identifier) { + bool CKStateChunk::SeekIdentifierDword(CKDWORD identifier) { CKDWORD cache; - return SeekIdentifierAndReturnSize(identifier, &cache); + return SeekIdentifierDwordAndReturnSize(identifier, &cache); } - bool CKStateChunk::SeekIdentifierAndReturnSize(CKDWORD identifier, CKDWORD* out_size) { + bool CKStateChunk::SeekIdentifierDwordAndReturnSize(CKDWORD identifier, CKDWORD* out_size) { if (this->m_Parser.m_Status != CKStateChunkStatus::READ) return false; CKDWORD pos = 0u; diff --git a/LibCmo/CKStateChunk.hpp b/LibCmo/CKStateChunk.hpp index 6b81185..b692458 100644 --- a/LibCmo/CKStateChunk.hpp +++ b/LibCmo/CKStateChunk.hpp @@ -62,9 +62,17 @@ namespace LibCmo::CK2 { public: void StartRead(void); - bool SeekIdentifier(CKDWORD identifier); - bool SeekIdentifierAndReturnSize(CKDWORD identifier, CKDWORD* out_size); - CKERROR ReadString(std::string& strl); + bool SeekIdentifierDword(CKDWORD identifier); + bool SeekIdentifierDwordAndReturnSize(CKDWORD identifier, CKDWORD* out_size); + template + inline bool SeekIdentifier(TEnum enum_v) { + return SeekIdentifierDword(static_cast(enum_v)); + } + template + inline bool SeekIdentifierAndReturnSize(TEnum enum_v, CKDWORD* out_size) { + return SeekIdentifierDwordAndReturnSize(static_cast(enum_v), out_size); + } + /* * Read Struct Primitive type: ReadInt, ReadByte, ReadWord, ReadDword, ReadFloat, etc... @@ -89,15 +97,17 @@ namespace LibCmo::CK2 { inline CKERROR ReadStructRef(T& data) { return ReadStructPtr(&data); } - /* - * Read Enum Data - A wrapper for ReadStructPtr. - All Enum read redirect to this. - */ - template - inline CKERROR ReadEnum(T& data) { - return ReadStructPtr(reinterpret_cast*>(&data)); - } + ///* + //* Read Enum Data + //A wrapper for ReadStructPtr. + //All Enum read redirect to this. + //*/ + //template + //inline CKERROR ReadEnum(T& data) { + // return ReadStructPtr(reinterpret_cast*>(&data)); + //} + + CKERROR ReadString(std::string& strl); CKERROR ReadBuffer(void* allocatedBuf); CKERROR ReadNoSizeBuffer(CKDWORD size, void* allocatedBuf); diff --git a/LibCmo/LibCmo.vcxproj b/LibCmo/LibCmo.vcxproj index 66297ee..7fd53fe 100644 --- a/LibCmo/LibCmo.vcxproj +++ b/LibCmo/LibCmo.vcxproj @@ -192,6 +192,7 @@ + diff --git a/LibCmo/LibCmo.vcxproj.filters b/LibCmo/LibCmo.vcxproj.filters index e187cb2..14ce278 100644 --- a/LibCmo/LibCmo.vcxproj.filters +++ b/LibCmo/LibCmo.vcxproj.filters @@ -89,5 +89,8 @@ Headers + + Headers + \ No newline at end of file diff --git a/LibCmo/VTUtils.hpp b/LibCmo/VTUtils.hpp index cd76466..9dab838 100644 --- a/LibCmo/VTUtils.hpp +++ b/LibCmo/VTUtils.hpp @@ -45,19 +45,34 @@ #include #include #include -#include namespace LibCmo { namespace EnumsHelper { template - inline TEnum FlagEnumAdd(TEnum e, ...) { - TEnum result = e; - va_list argptr; - va_start(argptr, e); - result = static_cast(static_cast>(result) | static_cast>(va_arg(argptr, TEnum))); - va_end(argptr); - return result; + inline TEnum FlagEnumMerge(std::initializer_list il) { + std::underlying_type_t result = 0u; + for (auto it = il.begin(); it != il.end(); ++it) { + result |= static_cast>(*it); + } + return static_cast(result); + } + + template + inline TEnum FlagEnumInv(TEnum e) { + return static_cast(~(static_cast>(e))); + } + + template + inline void FlagEnumRm(TEnum& e, std::initializer_list il) { + auto mask = FlagEnumInv(FlagEnumMerge(il)); + e = static_cast(static_cast>(e) & static_cast>(mask)); + } + + template + inline void FlagEnumAdd(TEnum& e, std::initializer_list il) { + auto mask = FlagEnumMerge(il); + e = static_cast(static_cast>(e) | static_cast>(mask)); } template diff --git a/Unvirt/StructFormatter.cpp b/Unvirt/StructFormatter.cpp index 4401850..06da5d7 100644 --- a/Unvirt/StructFormatter.cpp +++ b/Unvirt/StructFormatter.cpp @@ -11,8 +11,8 @@ namespace Unvirt { std::string container; fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileInfo\n")), fout); - fprintf(fout, "Version (File / CK): %" PRIu32 " / %02" PRIX32 "/%02" PRIX32 "/%04" PRIX32 "\n", - fileinfo.FileVersion, + fprintf(fout, "FileVersion: %" PRIu32 "\n", fileinfo.FileVersion); + fprintf(fout, "CKVersion: %02" PRIX32 "/%02" PRIX32 "/%04" PRIX32 "\n", (fileinfo.CKVersion >> 24) & 0xFF, (fileinfo.CKVersion >> 16) & 0xFF, (fileinfo.CKVersion >> 0) & 0xFFFF diff --git a/Unvirt/Unvirt.cpp b/Unvirt/Unvirt.cpp index b34830b..75b0940 100644 --- a/Unvirt/Unvirt.cpp +++ b/Unvirt/Unvirt.cpp @@ -18,7 +18,7 @@ int main(int argc, char* argv[]) { LibCmo::CK2::CKFile vtfile(&vtctx); LibCmo::CK2::CKFileData::DeepDocument* doc; - LibCmo::CK2::CKERROR err = vtfile.DeepLoad("Language.old.nmo", &doc); + LibCmo::CK2::CKERROR err = vtfile.DeepLoad("Level_01.NMO", &doc); if (doc) Unvirt::StructFormatter::PrintCKFileInfo(doc->m_FileInfo);