yyc12345/libcmo21
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor project

Browse Source
This commit is contained in:
yyc12345
2023-09-16 18:31:25 +08:00
parent 8f960604ca
commit 1ddeeb3b68
41 changed files with 725 additions and 749 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
LibCmo/CK2/CKBitmapData.cpp
View File

@ -220,7 +220,7 @@ namespace LibCmo::CK2 {
// read string in detail
// and try load not loaded image.
for (CKDWORD i = 0; i < slotcount; ++i) {
std::string filename;
XContainer::XString filename;
chunk->ReadString(filename);
if (filename.empty()) continue;
@ -298,7 +298,7 @@ namespace LibCmo::CK2 {
if (slot >= m_Slots.size()) return false;
// get extension of file. then get corresponding reader
std::string ext(filename);
XContainer::XString ext(filename);
m_Context->GetPathManager()->GetExtension(ext);
auto reader = DataHandlers::CKBitmapHandler::GetBitmapHandlerWrapper(CKFileExtension(ext.c_str()), CKGUID());
if (reader == nullptr) return false;
@ -320,7 +320,7 @@ namespace LibCmo::CK2 {
if (isForceThisFmt) {
savefmt = this->m_SaveProperties;
} else {
std::string ext(filename);
XContainer::XString ext(filename);
m_Context->GetPathManager()->GetExtension(ext);
if (ext.empty()) {
// fallback to this fmt

9
LibCmo/CK2/CKContext.cpp
View File

@ -3,7 +3,6 @@
#include "MgrImpls/CKBaseManager.hpp"
#include "MgrImpls/CKObjectManager.hpp"
#include "MgrImpls/CKPathManager.hpp"
#include "../XContainer/XBitArray.hpp"
#include <cstdarg>
namespace LibCmo::CK2 {
@ -262,7 +261,7 @@ namespace LibCmo::CK2 {
va_list argptr;
va_start(argptr, fmt);
std::string result;
XContainer::XString result;
int count = std::vsnprintf(nullptr, 0, fmt, argptr);
result.resize(count);
int write_result = std::vsnprintf(result.data(), count, fmt, argptr);
@ -282,7 +281,7 @@ namespace LibCmo::CK2 {
#pragma region Encoding utilities
void CKContext::GetUtf8String(const std::string& native_name, std::string& u8_name) {
void CKContext::GetUtf8String(const XContainer::XString& native_name, XContainer::XString& u8_name) {
bool success = false;
for (const auto& token : this->m_NameEncoding) {
success = LibCmo::EncodingHelper::GetUtf8VirtoolsName(native_name, u8_name, token);
@ -296,7 +295,7 @@ namespace LibCmo::CK2 {
}
}
void CKContext::GetNativeString(const std::string& u8_name, std::string& native_name) {
void CKContext::GetNativeString(const XContainer::XString& u8_name, XContainer::XString& native_name) {
bool success = false;
for (const auto& token : this->m_NameEncoding) {
success = LibCmo::EncodingHelper::GetNativeVirtoolsName(u8_name, native_name, token);
@ -310,7 +309,7 @@ namespace LibCmo::CK2 {
}
}
void CKContext::SetEncoding(const std::vector<std::string> encoding_series) {
void CKContext::SetEncoding(const XContainer::XArray<XContainer::XString> encoding_series) {
// free all current series
for (const auto& encoding : this->m_NameEncoding) {
LibCmo::EncodingHelper::DestroyEncodingToken(encoding);

6
LibCmo/CK2/CKContext.hpp
View File

@ -100,9 +100,9 @@ namespace LibCmo::CK2 {
// ========== Encoding utilities ==========
public:
void GetUtf8String(const std::string& native_name, std::string& u8_name);
void GetNativeString(const std::string& u8_name, std::string& native_name);
void SetEncoding(const std::vector<std::string> encoding_series);
void GetUtf8String(const XContainer::XString& native_name, XContainer::XString& u8_name);
void GetNativeString(const XContainer::XString& u8_name, XContainer::XString& native_name);
void SetEncoding(const XContainer::XArray<XContainer::XString> encoding_series);
protected:
std::vector<EncodingHelper::ENCODING_TOKEN> m_NameEncoding;

165
LibCmo/CK2/CKDefines.hpp
View File

@ -1,15 +1,52 @@
#pragma once
#include "../VTUtils.hpp"
#include "CKTypes.hpp"
#include "../XContainer/XTypes.hpp"
#include <string>
#include <vector>
#include <cstring>
#include <cinttypes>
#include <functional>
#include "CKGlobals.hpp"
namespace LibCmo::CK2 {
#pragma region Preregistred Managers
// Virtools Managers GUID second data is 0
constexpr const CKDWORD OBJECT_MANAGER_GUID1 = 0x7cbb3b91;
constexpr const CKDWORD ATTRIBUTE_MANAGER_GUID1 = 0x3d242466;
constexpr const CKDWORD MESSAGE_MANAGER_GUID1 = 0x466a0fac;
constexpr const CKDWORD FLOOR_MANAGER_GUID1 = 0x420936f9;
constexpr const CKDWORD COLLISION_MANAGER_GUID1 = 0x38244712;
constexpr const CKDWORD GRID_MANAGER_GUID1 = 0x7f004791;
constexpr const CKDWORD TIME_MANAGER_GUID1 = 0x89ce7b32;
constexpr const CKDWORD BEHAVIOR_MANAGER_GUID1 = 0x58d621ae;
constexpr const CKDWORD INPUT_MANAGER_GUID1 = 0xf787c904;
constexpr const CKDWORD SOUND_MANAGER_GUID1 = 0xdce135f6;
constexpr const CKDWORD MIDI_MANAGER_GUID1 = 0x594154a6;
constexpr const CKDWORD INTERFACE_MANAGER_GUID1 = 0x9a4b8e3d;
constexpr const CKDWORD RENDER_MANAGER_GUID1 = 0xa213c8d5;
constexpr const CKDWORD PARAMETER_MANAGER_GUID1 = 0x9ce57ab6;
constexpr const CKDWORD PATH_MANAGER_GUID1 = 0x15fd54b9;
constexpr const CKDWORD VARIABLE_MANAGER_GUID1 = 0x98cc3cc9;
constexpr const CKGUID OBJECT_MANAGER_GUID{ OBJECT_MANAGER_GUID1 ,0 };
constexpr const CKGUID ATTRIBUTE_MANAGER_GUID{ ATTRIBUTE_MANAGER_GUID1, 0 };
constexpr const CKGUID MESSAGE_MANAGER_GUID{ MESSAGE_MANAGER_GUID1 ,0 };
constexpr const CKGUID TIME_MANAGER_GUID{ TIME_MANAGER_GUID1 ,0 };
constexpr const CKGUID SOUND_MANAGER_GUID{ SOUND_MANAGER_GUID1 ,0 };
constexpr const CKGUID MIDI_MANAGER_GUID{ MIDI_MANAGER_GUID1 ,0 };
constexpr const CKGUID INPUT_MANAGER_GUID{ INPUT_MANAGER_GUID1 ,0 };
constexpr const CKGUID BEHAVIOR_MANAGER_GUID{ BEHAVIOR_MANAGER_GUID1 ,0 };
constexpr const CKGUID FLOOR_MANAGER_GUID{ FLOOR_MANAGER_GUID1 ,0 };
constexpr const CKGUID COLLISION_MANAGER_GUID{ COLLISION_MANAGER_GUID1 ,0 };
constexpr const CKGUID GRID_MANAGER_GUID{ GRID_MANAGER_GUID1 ,0 };
constexpr const CKGUID INTERFACE_MANAGER_GUID{ INTERFACE_MANAGER_GUID1 ,0 };
constexpr const CKGUID RENDER_MANAGER_GUID{ RENDER_MANAGER_GUID1 ,0 };
constexpr const CKGUID PARAMETER_MANAGER_GUID{ PARAMETER_MANAGER_GUID1 ,0 };
constexpr const CKGUID PATH_MANAGER_GUID{ PATH_MANAGER_GUID1 ,0 };
constexpr const CKGUID VARIABLE_MANAGER_GUID{ VARIABLE_MANAGER_GUID1 ,0 };
#pragma endregion
#pragma region Misc Constant
/**
* @brief The identifier of Virtools file.
*/
@ -25,53 +62,83 @@ namespace LibCmo::CK2 {
constexpr const CKDWORD DEVVERSION = 0u;
constexpr const CKGUID VIRTOOLS_GUID = CKGUID(0x56495254u, 0x4f4f4c53u);
// ========== Class registration utilities ==========
#pragma endregion
//using CKClassRegisterFct = std::function<void()>;
using CKClassCreationFct = std::function<ObjImpls::CKObject* (CKContext*, CK_ID, CKSTRING)>;
using CKClassReleaseFct = std::function<void(CKContext*, ObjImpls::CKObject*)>;
using CKClassNameFct = std::function<CKSTRING()>;
//using CKClassDependenciesFct = std::function<CKSTRING(CKINT, CKINT)>;
//using CKClassDependenciesCountFct = std::function<CKINT(CKINT)>;
#pragma region Common Used Struct
// a stupid forward decl to remove something
/**
* @brief Storage class for filename extensions
*/
class CKFileExtension {
public:
CKFileExtension() : m_Data() {
std::memset(m_Data, 0, c_DataLen);
}
CKFileExtension(CKSTRING s) : CKFileExtension() {
SetExt(s);
}
CKFileExtension(const CKFileExtension& rhs) : CKFileExtension() {
std::memcpy(m_Data, rhs.m_Data, c_DataLen);
}
CKFileExtension(CKFileExtension&& rhs) : CKFileExtension() {
std::memmove(m_Data, rhs.m_Data, c_DataLen);
std::memset(rhs.m_Data, 0, c_DataLen);
}
CKFileExtension& operator=(const CKFileExtension& rhs) {
std::memcpy(m_Data, rhs.m_Data, c_DataLen);
return *this;
}
CKFileExtension& operator=(CKFileExtension&& rhs) {
std::memmove(m_Data, rhs.m_Data, c_DataLen);
std::memset(rhs.m_Data, 0, c_DataLen);
return *this;
}
struct CKClassDesc {
bool IsValid; /**< True if this CKClassDesc is a valid one. Because CK_CLASSID may not be consecutive. */
bool Done;
// Initialized upon class registration
CK_CLASSID Self;
CK_CLASSID Parent; // Class Identifier of parent class
//CKClassRegisterFct RegisterFct; // Pointer to Class Specific Registration function
CKClassCreationFct CreationFct; // Pointer to Class instance creation function
CKClassReleaseFct ReleaseFct; // Pointer to Class instance release function
CKClassNameFct NameFct; // Pointer to Class name function
//CKClassDependenciesFct DependsFct; // Pointer to Class dependencies function (Copy,delete,replace...)
//CKClassDependenciesCountFct DependsCountFct; // Pointer to Class dependencies Count function (Copy,delete,replace...)
void SetExt(CKSTRING s) {
if (s == nullptr) {
m_Data[0] = '\0';
} else {
if (s[0] == '.') ++s; // skip dot
size_t len = std::strlen(s);
if (len > (c_DataLen - 1)) len = c_DataLen - 1;
std::memcpy(m_Data, s, len);
}
}
//// Initialized by class specific registration function
//CKDWORD DefaultOptions; // Default options for this class
//CKDWORD DefaultCopyDependencies;
//CKDWORD DefaultDeleteDependencies;
//CKDWORD DefaultReplaceDependencies;
//CKDWORD DefaultSaveDependencies;
//CKGUID Parameter; // Associated parameter GUID
CKSTRING GetExt() const {
return m_Data;
}
// Initialized when building class hierarchy table
CKINT DerivationLevel; // O => CKObject , etc..
XContainer::XBitArray Parents; // Bit Mask of parents classes
XContainer::XBitArray Children; // Bit Mask of children classes
//XContainer::XBitArray ToBeNotify; // Mask for Classes that should warn the objects of this class when they are deleted
//XContainer::XBitArray CommonToBeNotify; // idem but merged with sub classes masks
//XContainer::XSArray<CK_CLASSID> ToNotify; // List of ClassID to notify when an object of this class is deleted (inverse of ToBeNotify)
bool operator==(const CKFileExtension& rhs) const {
return CKStrEqualI(m_Data, rhs.m_Data);
}
CKClassDesc() :
IsValid(false),
Done(false),
Self(CK_CLASSID::CKCID_OBJECT), Parent(CK_CLASSID::CKCID_OBJECT),
CreationFct(nullptr), ReleaseFct(nullptr), NameFct(nullptr),
DerivationLevel(0),
Parents(), Children()
{}
LIBCMO_DEFAULT_COPY_MOVE(CKClassDesc);
protected:
static constexpr size_t c_DataLen = 4u;
CKCHAR m_Data[c_DataLen];
};
/**
* The struct describe the bitmap handler's infomation,
* including its GUID and supported file extension.
* This struct also will store some parameters related to bitmap handler,
* such as jpeg compress level and etc. But currently there are no
* such parameters.
*/
class CKBitmapProperties {
public:
CKBitmapProperties() :
m_ReaderGuid(), m_Ext() {}
CKBitmapProperties(const CKGUID& guid, CKSTRING ext) :
m_ReaderGuid(guid), m_Ext(ext) {}
LIBCMO_DEFAULT_COPY_MOVE(CKBitmapProperties);
CKGUID m_ReaderGuid; /**< CKGUID that uniquely identifies the reader that created this properties structure */
CKFileExtension m_Ext; /**< File Extension of the image being described by this structure */
};
#pragma endregion
}

68
LibCmo/CK2/CKEnums.hpp
View File

@ -7,46 +7,6 @@
namespace LibCmo::CK2 {
#pragma region Preregistred Managers
// Virtools Managers GUID second data is 0
constexpr const CKDWORD OBJECT_MANAGER_GUID1 = 0x7cbb3b91;
constexpr const CKDWORD ATTRIBUTE_MANAGER_GUID1 = 0x3d242466;
constexpr const CKDWORD MESSAGE_MANAGER_GUID1 = 0x466a0fac;
constexpr const CKDWORD FLOOR_MANAGER_GUID1 = 0x420936f9;
constexpr const CKDWORD COLLISION_MANAGER_GUID1 = 0x38244712;
constexpr const CKDWORD GRID_MANAGER_GUID1 = 0x7f004791;
constexpr const CKDWORD TIME_MANAGER_GUID1 = 0x89ce7b32;
constexpr const CKDWORD BEHAVIOR_MANAGER_GUID1 = 0x58d621ae;
constexpr const CKDWORD INPUT_MANAGER_GUID1 = 0xf787c904;
constexpr const CKDWORD SOUND_MANAGER_GUID1 = 0xdce135f6;
constexpr const CKDWORD MIDI_MANAGER_GUID1 = 0x594154a6;
constexpr const CKDWORD INTERFACE_MANAGER_GUID1 = 0x9a4b8e3d;
constexpr const CKDWORD RENDER_MANAGER_GUID1 = 0xa213c8d5;
constexpr const CKDWORD PARAMETER_MANAGER_GUID1 = 0x9ce57ab6;
constexpr const CKDWORD PATH_MANAGER_GUID1 = 0x15fd54b9;
constexpr const CKDWORD VARIABLE_MANAGER_GUID1 = 0x98cc3cc9;
constexpr const CKGUID OBJECT_MANAGER_GUID{ OBJECT_MANAGER_GUID1 ,0 };
constexpr const CKGUID ATTRIBUTE_MANAGER_GUID{ ATTRIBUTE_MANAGER_GUID1, 0 };
constexpr const CKGUID MESSAGE_MANAGER_GUID{ MESSAGE_MANAGER_GUID1 ,0 };
constexpr const CKGUID TIME_MANAGER_GUID{ TIME_MANAGER_GUID1 ,0 };
constexpr const CKGUID SOUND_MANAGER_GUID{ SOUND_MANAGER_GUID1 ,0 };
constexpr const CKGUID MIDI_MANAGER_GUID{ MIDI_MANAGER_GUID1 ,0 };
constexpr const CKGUID INPUT_MANAGER_GUID{ INPUT_MANAGER_GUID1 ,0 };
constexpr const CKGUID BEHAVIOR_MANAGER_GUID{ BEHAVIOR_MANAGER_GUID1 ,0 };
constexpr const CKGUID FLOOR_MANAGER_GUID{ FLOOR_MANAGER_GUID1 ,0 };
constexpr const CKGUID COLLISION_MANAGER_GUID{ COLLISION_MANAGER_GUID1 ,0 };
constexpr const CKGUID GRID_MANAGER_GUID{ GRID_MANAGER_GUID1 ,0 };
constexpr const CKGUID INTERFACE_MANAGER_GUID{ INTERFACE_MANAGER_GUID1 ,0 };
constexpr const CKGUID RENDER_MANAGER_GUID{ RENDER_MANAGER_GUID1 ,0 };
constexpr const CKGUID PARAMETER_MANAGER_GUID{ PARAMETER_MANAGER_GUID1 ,0 };
constexpr const CKGUID PATH_MANAGER_GUID{ PATH_MANAGER_GUID1 ,0 };
constexpr const CKGUID VARIABLE_MANAGER_GUID{ VARIABLE_MANAGER_GUID1 ,0 };
#pragma endregion
/**
Specify the way files are saved to disk (compression)
@remark
@ -57,7 +17,7 @@ namespace LibCmo::CK2 {
@see CKContext::SetFileWriteMode, CKContext::GetFileWriteMode, CKContext::SetCompressionLevel,
CKContext::SetGlobalImagesSaveOptions, CKContext::SetGlobalSoundsSaveOptions
*/
enum class CK_FILE_WRITEMODE : uint32_t {
enum class CK_FILE_WRITEMODE : CKDWORD {
CKFILE_UNCOMPRESSED = 0, /**< Save data uncompressed */
CKFILE_CHUNKCOMPRESSED_OLD = 1, /**< Obsolete */
CKFILE_EXTERNALTEXTURES_OLD = 2, /**< Obsolete : use CKContext::SetGlobalImagesSaveOptions instead. */
@ -75,7 +35,7 @@ namespace LibCmo::CK2 {
created CKObjects should be created as dynamic (See also Dynamic Objects)
See also : CKContext::Load, CKContext::CKSave
*/
enum class CK_LOAD_FLAGS : uint32_t {
enum class CK_LOAD_FLAGS : CKDWORD {
CK_LOAD_ANIMATION = 1 << 0, /**< Load animations */
CK_LOAD_GEOMETRY = 1 << 1, /**< Load geometry. */
CK_LOAD_DEFAULT = CK_LOAD_GEOMETRY | CK_LOAD_ANIMATION, /**< Load animations & geometry */
@ -90,7 +50,7 @@ namespace LibCmo::CK2 {
/**
Options that will be used to create this object...
*/
enum class CK_FO_OPTIONS : uint32_t {
enum class CK_FO_OPTIONS : CKDWORD {
CK_FO_DEFAULT = 0, /**< Default behavior : a new object will be created with the name stored in CKFileObject */
CK_FO_RENAMEOBJECT, /**< Renaming : a new object will be created with the name stored in CKFileObject + a integer value XXX to ensure its uniqueness */
CK_FO_REPLACEOBJECT, /**< Do not create a new object, instead use an existing one which CK_ID is given by CreatedObject to load the chunk on */
@ -99,7 +59,7 @@ namespace LibCmo::CK2 {
/**
@brief Specify the way an object just loaded should be handled when it already exists in the level.
*/
enum class CK_LOADMODE : int32_t {
enum class CK_LOADMODE : CKINT {
CKLOAD_INVALID = -1, /**< Use the existing object instead of loading */
CKLOAD_OK = 0, /**< Ignore ( Name unicity is broken ) */
CKLOAD_REPLACE = 1, /**< Replace the existing object (Not yet implemented) */
@ -115,7 +75,7 @@ namespace LibCmo::CK2 {
dynamic.
@see CKContext::CreateObject
*/
enum class CK_OBJECTCREATION_OPTIONS : uint32_t {
enum class CK_OBJECTCREATION_OPTIONS : CKDWORD {
CK_OBJECTCREATION_NONAMECHECK = 0, /**< Do not test for name unicity (may be overriden in special case) */
CK_OBJECTCREATION_REPLACE = 1, /**< Replace the current object by the object being loaded */
CK_OBJECTCREATION_RENAME = 2, /**< Rename the created object to ensure its uniqueness */
@ -135,7 +95,7 @@ namespace LibCmo::CK2 {
@see CKPluginManager
*/
enum class CK_PLUGIN_TYPE : uint32_t {
enum class CK_PLUGIN_TYPE : CKDWORD {
CKPLUGIN_BITMAP_READER = 0, /**< The plugin is bitmap (textures,sprites) loader */
CKPLUGIN_SOUND_READER = 1, /**< Sound Reader Plugin */
CKPLUGIN_MODEL_READER = 2, /**< 3D Model Reader */
@ -148,7 +108,7 @@ namespace LibCmo::CK2 {
/**
@remark CHUNK_OPTIONS in original Virtools header.
*/
enum class CK_STATECHUNK_CHUNKOPTIONS : uint32_t {
enum class CK_STATECHUNK_CHUNKOPTIONS : CKDWORD {
CHNK_OPTION_IDS = 0x01, /**< IDS are stored inside chunk */
CHNK_OPTION_MAN = 0x02, /**< Managers ints are store inside chunk */
CHNK_OPTION_CHN = 0x04, /**< Sub chunk are stored inside chunk */
@ -158,14 +118,14 @@ namespace LibCmo::CK2 {
CHNK_DONTDELETE_PTR = 0x40, /**< Data buffer stored in m_Buffer is not owned by CKStateChunk , it must not be deleted... */
CHNK_DONTDELETE_PARSER = 0x80, /**< m_Parser Ptr is not owned by CKStateChunk , it must not be deleted... */
};
enum class CK_STATECHUNK_CHUNKVERSION : uint32_t {
enum class CK_STATECHUNK_CHUNKVERSION : CKDWORD {
CHUNK_VERSIONBASE = 0,
CHUNK_VERSION1 = 4, /**< equal to file version : WriteObjectID => table */
CHUNK_VERSION2 = 5, /**< add Manager Data */
CHUNK_VERSION3 = 6, /**< New ConvertToBuffer / ReadFromBuffer (file system changed to reflect this ) */
CHUNK_VERSION4 = 7, /**< New WriteObjectID when saving to a file */
};
enum class CK_STATECHUNK_DATAVERSION : uint32_t {
enum class CK_STATECHUNK_DATAVERSION : CKDWORD {
CHUNKDATA_OLDVERSION = 0, /**< Before any version was saved */
CHUNKDATA_BASEVERSION = 1, /**< First version */
CHUNK_WAVESOUND_VERSION2 = 2, /**< Changes in wavesound format */
@ -188,7 +148,7 @@ namespace LibCmo::CK2 {
you should always use the specific acces function (given between ()) which may need to perform additionnal operations.
@see CKObject, CKObject::GetObjectFlags, CKObject::ModifyObjectFlags
*/
enum class CK_OBJECT_FLAGS : uint32_t {
enum class CK_OBJECT_FLAGS : CKDWORD {
CK_OBJECT_INTERFACEOBJ = 0x00000001, /**< Reserved for Inteface Use */
CK_OBJECT_PRIVATE = 0x00000002, /**< The object must not be displayed in interface (Lists,Level view,etc...),nor should it be saved. (CKObject::IsPrivate() */
CK_OBJECT_INTERFACEMARK = 0x00000004,
@ -230,7 +190,7 @@ namespace LibCmo::CK2 {
+ Flags give user and engine more information about the 3dEntity.
@see CK3dEntity::SetFlags,CK3dEntity::GetFlags
*/
enum class CK_3DENTITY_FLAGS : uint32_t {
enum class CK_3DENTITY_FLAGS : CKDWORD {
CK_3DENTITY_DUMMY = 0x00000001, /**< Entity is a dummy used to represent a position */
CK_3DENTITY_FRAME = 0x00000002, /**< Entity is a frame used to represent an orientation */
CK_3DENTITY_RESERVED0 = 0x00000020, /**< Obsolete Flag */
@ -258,7 +218,7 @@ namespace LibCmo::CK2 {
+ These options can be used for a specific texture (or sprite) or as a global setting.
See also: CKBitmapData::SetSaveOptions,CKSprite::SetSaveOptions,CKContext::SetGlobalImagesSaveOptions
*/
enum class CK_TEXTURE_SAVEOPTIONS : uint32_t {
enum class CK_TEXTURE_SAVEOPTIONS : CKDWORD {
CKTEXTURE_RAWDATA = 0, /**< Save raw data inside file. The bitmap is saved in a raw 32 bit per pixel format. */
CKTEXTURE_EXTERNAL = 1, /**< Store only the file name for the texture. The bitmap file must be present in the bitmap paths when loading the composition. */
CKTEXTURE_IMAGEFORMAT = 2, /**< Save using format specified. The bitmap data will be converted to the specified format by the correspondant bitmap plugin and saved inside file. */
@ -275,13 +235,13 @@ namespace LibCmo::CK2 {
+ These options can be used for a specific sound or as a global setting.
See also: CKSound::SetSaveOptions,CKContext::SetGlobalSoundSaveOptions
*/
enum class CK_SOUND_SAVEOPTIONS : uint32_t {
enum class CK_SOUND_SAVEOPTIONS : CKDWORD {
CKSOUND_EXTERNAL = 0, /**< Store only the file name for the sound. The sound file must be present in one of the sound paths when the composition is loaded. */
CKSOUND_INCLUDEORIGINALFILE = 1, /**< Insert original sound file inside the CMO file. The sound file that was used originally will be append to the composition file and extracted when the file is loaded. */
CKSOUND_USEGLOBAL = 2, /**< Use Global settings. This flag is only valid for the CKSound::SetSaveOptions method. */
};
enum class CK_BITMAPDATA_FLAGS : uint32_t {
enum class CK_BITMAPDATA_FLAGS : CKDWORD {
CKBITMAPDATA_INVALID = 1,
CKBITMAPDATA_TRANSPARENT = 2,
CKBITMAPDATA_FORCERESTORE = 4,

6
LibCmo/CK2/CKFile.hpp
View File

@ -3,8 +3,8 @@
#include "../VTAll.hpp"
namespace LibCmo::XContainer {
using XIntArray = XArray<CK2::CKINT>;
using XFileObjectsTable = XHashTable<CK2::CK_ID, CK2::CKINT>;
using XIntArray = XArray<CKINT>;
using XFileObjectsTable = XHashTable<CK2::CK_ID, CKINT>;
}
namespace LibCmo::CK2 {
@ -120,7 +120,7 @@ namespace LibCmo::CK2 {
CK_ID CreatedObjectId; /**< ID of the object being created */
CK_CLASSID ObjectCid; /**< Class Identifier of the object */
ObjImpls::CKObject* ObjPtr; /**< A pointer to the object itself (as CreatedObject when loading) */
TypeHelper::MKString Name; /**< Name of the Object */
XContainer::XString Name; /**< Name of the Object */
CKStateChunk* Data; /**< A CKStateChunk that contains object information */
CKDWORD PackSize; /**< The CKStateChunk data size */
//CKINT PostPackSize; /**< When compressed chunk by chunk : size of Data after compression */

13
LibCmo/CK2/CKFileReader.cpp
View File

@ -42,7 +42,7 @@ namespace LibCmo::CK2 {
std::unique_ptr<CKBufferParser> parser(new CKBufferParser(ParserPtr->GetBase(), ParserPtr->GetSize(), false));
parser->SetCursor(ParserPtr->GetCursor());
std::string name_conv, name_dest;
XContainer::XString name_conv;
// ========== read header ==========
// check header size
@ -129,8 +129,9 @@ namespace LibCmo::CK2 {
if (namelen != 0) {
name_conv.resize(namelen);
parser->Read(name_conv.data(), namelen);
m_Ctx->GetUtf8String(name_conv, name_dest);
fileobj.Name = name_dest;
m_Ctx->GetUtf8String(name_conv, fileobj.Name);
} else {
fileobj.Name.clear();
}
}
}
@ -196,7 +197,7 @@ namespace LibCmo::CK2 {
std::unique_ptr<CKBufferParser> parser(new CKBufferParser(ParserPtr->GetBase(), ParserPtr->GetSize(), false));
parser->SetCursor(ParserPtr->GetCursor());
std::string name_conv;
XContainer::XString name_conv;
// ========== compress feature process ==========
if (EnumsHelper::Has(this->m_FileInfo.FileWriteMode, CK_FILE_WRITEMODE::CKFILE_CHUNKCOMPRESSED_OLD) ||
@ -314,7 +315,7 @@ namespace LibCmo::CK2 {
parser->Read(&filebodylen, sizeof(CKDWORD));
// read file body
std::string tempfilename = m_Ctx->GetPathManager()->GetTempFilePath(file.c_str());
XContainer::XString tempfilename = m_Ctx->GetPathManager()->GetTempFilePath(file.c_str());
FILE* fp = EncodingHelper::U8FOpen(tempfilename.c_str(), "wb");
if (fp != nullptr) {
std::fwrite(parser->GetPtr(), sizeof(char), filebodylen, fp);
@ -349,7 +350,7 @@ namespace LibCmo::CK2 {
if (obj.Data == nullptr) continue;
// create object and assign created obj ckid
obj.ObjPtr = m_Ctx->CreateObject(obj.ObjectCid, obj.Name.toCKSTRING());
obj.ObjPtr = m_Ctx->CreateObject(obj.ObjectCid, XContainer::NSXString::ToCKSTRING(obj.Name));
if (obj.ObjPtr == nullptr) {
obj.CreatedObjectId = 0u;
} else {

12
LibCmo/CK2/CKFileWriter.cpp
View File

@ -14,7 +14,7 @@ namespace LibCmo::CK2 {
if (this->m_Done) CKERROR::CKERR_CANCELLED;
// encoding conv helper
std::string name_conv;
XContainer::XString name_conv;
// try detect filename legality
CKERROR err = PrepareFile(u8_filename);
@ -90,9 +90,9 @@ namespace LibCmo::CK2 {
for (auto& obj : m_FileObjects) {
// += 4DWORD(ObjId, ObjCid, FileIndex, NameLen)
sumHdrObjSize += 4 * CKSizeof(CKDWORD);
if (obj.Name.toCKSTRING() != nullptr) {
if (XContainer::NSXString::ToCKSTRING(obj.Name) != nullptr) {
// += Name size
m_Ctx->GetNativeString(obj.Name.toString(), name_conv);
m_Ctx->GetNativeString(obj.Name, name_conv);
sumHdrObjSize += static_cast<CKDWORD>(name_conv.size());
}
@ -177,8 +177,8 @@ namespace LibCmo::CK2 {
hdrparser->Write(&obj.ObjectCid, sizeof(CK_CLASSID));
hdrparser->Write(&obj.FileIndex, sizeof(CKDWORD));
if (obj.Name.toCKSTRING() != nullptr) {
m_Ctx->GetNativeString(obj.Name.toString(), name_conv);
if (XContainer::NSXString::ToCKSTRING(obj.Name) != nullptr) {
m_Ctx->GetNativeString(obj.Name, name_conv);
CKDWORD namelen = static_cast<CKDWORD>(name_conv.size());
hdrparser->Write(&namelen, sizeof(CKDWORD));
hdrparser->Write(name_conv.data(), namelen);
@ -316,7 +316,7 @@ namespace LibCmo::CK2 {
std::fwrite(name_conv.data(), sizeof(char), filenamelen, fs);
// try mapping file.
std::string tempfilename = m_Ctx->GetPathManager()->GetTempFilePath(fentry.c_str());
XContainer::XString tempfilename = m_Ctx->GetPathManager()->GetTempFilePath(fentry.c_str());
std::unique_ptr<VxMath::VxMemoryMappedFile> mappedFile(new VxMath::VxMemoryMappedFile(tempfilename.c_str()));
if (mappedFile->IsValid()) {
// write file length

38
LibCmo/CK2/CKGlobals.cpp
View File

@ -3,13 +3,12 @@
#define ZLIB_WINAPI
#endif
#include <zconf.h>
#include "../VTEncoding.hpp"
#include "CKGlobals.hpp"
#include <map>
#include <algorithm>
#include <zlib.h>
#include "CKGlobals.hpp"
#include <algorithm>
#include "ObjImpls/CKObject.hpp"
#include "ObjImpls/CKSceneObject.hpp"
#include "ObjImpls/CKBeObject.hpp"
@ -277,35 +276,6 @@ CKClassRegister(cid, parentCid, \
#undef EasyClassReg
/*
// register CKObjects
m_ObjectsCreationMap{
{CK_CLASSID::CKCID_OBJECT, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKObject(ctx, id, name); })},
{CK_CLASSID::CKCID_SCENEOBJECT, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKSceneObject(ctx, id, name); })},
{CK_CLASSID::CKCID_BEOBJECT, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKBeObject(ctx, id, name); })},
{CK_CLASSID::CKCID_GROUP, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKGroup(ctx, id, name); })},
{CK_CLASSID::CKCID_MESH, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKMesh(ctx, id, name); })},
{CK_CLASSID::CKCID_TEXTURE, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKTexture(ctx, id, name); })},
{CK_CLASSID::CKCID_MATERIAL, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKMaterial(ctx, id, name); })},
{CK_CLASSID::CKCID_RENDEROBJECT, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKRenderObject(ctx, id, name); })},
{CK_CLASSID::CKCID_3DENTITY, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CK3dEntity(ctx, id, name); })},
{CK_CLASSID::CKCID_PARAMETERIN, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKParameterIn(ctx, id, name); })},
{CK_CLASSID::CKCID_PARAMETER, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKParameter(ctx, id, name); })},
{CK_CLASSID::CKCID_PARAMETEROUT, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKParameterOut(ctx, id, name); })},
{CK_CLASSID::CKCID_PARAMETERLOCAL, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKParameterLocal(ctx, id, name); })},
{CK_CLASSID::CKCID_PARAMETEROPERATION, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKParameterOperation(ctx, id, name); })},
{CK_CLASSID::CKCID_BEHAVIORLINK, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKBehaviorLink(ctx, id, name); })},
{CK_CLASSID::CKCID_BEHAVIORIO, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKBehaviorLink(ctx, id, name); })},
{CK_CLASSID::CKCID_BEHAVIOR, ([](CKContext* ctx, CK_ID id, CKSTRING name) ->CKObjectImplements::CKObject* { return new(std::nothrow) CKObjectImplements::CKBehavior(ctx, id, name); })}
},
// register CKBaseManagers
m_ManagersCreationMap{
{ATTRIBUTE_MANAGER_GUID, ([](CKContext* ctx, CK_ID id) ->CKManagerImplements::CKBaseManager* { return new(std::nothrow) CKManagerImplements::CKAttributeManager(ctx, id); })},
}
*/
CKBuildClassHierarchyTable();
return CKERROR::CKERR_OK;

56
LibCmo/CK2/CKGlobals.hpp
View File

@ -1,6 +1,8 @@
#pragma once
#include "CKDefines.hpp"
#include "CKTypes.hpp"
#include "../XContainer/XTypes.hpp"
#include <functional>
namespace LibCmo::CK2 {
@ -70,12 +72,54 @@ namespace LibCmo::CK2 {
*/
bool CKStrEmpty(CKSTRING strl);
// ========== Numberic Utilities ==========
// ========== Class registration utilities ==========
/*
The convenient sizeof which return CKDWORD, not size_t.
*/
#define CKSizeof(_Ty) (static_cast<LibCmo::CK2::CKDWORD>(sizeof(_Ty)))
//using CKClassRegisterFct = std::function<void()>;
using CKClassCreationFct = std::function<ObjImpls::CKObject* (CKContext*, CK_ID, CKSTRING)>;
using CKClassReleaseFct = std::function<void(CKContext*, ObjImpls::CKObject*)>;
using CKClassNameFct = std::function<CKSTRING()>;
//using CKClassDependenciesFct = std::function<CKSTRING(CKINT, CKINT)>;
//using CKClassDependenciesCountFct = std::function<CKINT(CKINT)>;
struct CKClassDesc {
bool IsValid; /**< True if this CKClassDesc is a valid one. Because CK_CLASSID may not be consecutive. */
bool Done;
// Initialized upon class registration
CK_CLASSID Self;
CK_CLASSID Parent; // Class Identifier of parent class
//CKClassRegisterFct RegisterFct; // Pointer to Class Specific Registration function
CKClassCreationFct CreationFct; // Pointer to Class instance creation function
CKClassReleaseFct ReleaseFct; // Pointer to Class instance release function
CKClassNameFct NameFct; // Pointer to Class name function
//CKClassDependenciesFct DependsFct; // Pointer to Class dependencies function (Copy,delete,replace...)
//CKClassDependenciesCountFct DependsCountFct; // Pointer to Class dependencies Count function (Copy,delete,replace...)
//// Initialized by class specific registration function
//CKDWORD DefaultOptions; // Default options for this class
//CKDWORD DefaultCopyDependencies;
//CKDWORD DefaultDeleteDependencies;
//CKDWORD DefaultReplaceDependencies;
//CKDWORD DefaultSaveDependencies;
//CKGUID Parameter; // Associated parameter GUID
// Initialized when building class hierarchy table
CKINT DerivationLevel; // O => CKObject , etc..
XContainer::XBitArray Parents; // Bit Mask of parents classes
XContainer::XBitArray Children; // Bit Mask of children classes
//XContainer::XBitArray ToBeNotify; // Mask for Classes that should warn the objects of this class when they are deleted
//XContainer::XBitArray CommonToBeNotify; // idem but merged with sub classes masks
//XContainer::XSArray<CK_CLASSID> ToNotify; // List of ClassID to notify when an object of this class is deleted (inverse of ToBeNotify)
CKClassDesc() :
IsValid(false),
Done(false),
Self(CK_CLASSID::CKCID_OBJECT), Parent(CK_CLASSID::CKCID_OBJECT),
CreationFct(nullptr), ReleaseFct(nullptr), NameFct(nullptr),
DerivationLevel(0),
Parents(), Children()
{}
LIBCMO_DEFAULT_COPY_MOVE(CKClassDesc);
};
// ========== CKClass Registration ==========

84
LibCmo/CK2/CKIdentifiers.hpp
View File

@ -15,7 +15,7 @@ namespace LibCmo::CK2 {
/**
Object
*/
enum class CK_STATESAVEFLAGS_OBJECT : uint32_t {
enum class CK_STATESAVEFLAGS_OBJECT : CKDWORD {
CK_STATESAVE_NAME = 0x00000001, /**< Obsolete */
CK_STATESAVE_ID = 0x00000002, /**< Obsolete */
CK_STATESAVE_OBJECTHIDDEN = 0x00000004, /**< The object is hidden */
@ -25,7 +25,7 @@ namespace LibCmo::CK2 {
/**
Be Object
*/
enum class CK_STATESAVEFLAGS_BEOBJECT : uint32_t {
enum class CK_STATESAVEFLAGS_BEOBJECT : CKDWORD {
CK_STATESAVE_ATTRIBUTES = 0x00000010, /**< Obsolete */
CK_STATESAVE_NEWATTRIBUTES = 0x00000011, /**< Save Attributes */
CK_STATESAVE_GROUPS = 0x00000020, /**< Obsolete */
@ -41,7 +41,7 @@ namespace LibCmo::CK2 {
/**
3dEntity
*/
enum class CK_STATESAVEFLAGS_3DENTITY : uint32_t {
enum class CK_STATESAVEFLAGS_3DENTITY : CKDWORD {
CK_STATESAVE_3DENTITYSKINDATANORMALS = 0x00001000, /**< Save Skin normals */
CK_STATESAVE_ANIMATION = 0x00002000, /**< Obsolete */
CK_STATESAVE_MESHS = 0x00004000, /**< Save List of mesh */
@ -58,7 +58,7 @@ namespace LibCmo::CK2 {
/**
Light
*/
enum class CK_STATESAVEFLAGS_LIGHT : uint32_t {
enum class CK_STATESAVEFLAGS_LIGHT : CKDWORD {
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 */
@ -77,7 +77,7 @@ namespace LibCmo::CK2 {
/**
Camera
*/
enum class CK_STATESAVEFLAGS_CAMERA : uint32_t {
enum class CK_STATESAVEFLAGS_CAMERA : CKDWORD {
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 */
@ -95,7 +95,7 @@ namespace LibCmo::CK2 {
/**
Sprite3D
*/
enum class CK_STATESAVEFLAGS_SPRITE3D : uint32_t {
enum class CK_STATESAVEFLAGS_SPRITE3D : CKDWORD {
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 */
@ -108,7 +108,7 @@ namespace LibCmo::CK2 {
/**
Object 3D
*/
enum class CK_STATESAVEFLAGS_3DOBJECT : uint32_t {
enum class CK_STATESAVEFLAGS_3DOBJECT : CKDWORD {
CK_STATESAVE_3DOBJECTATTRIBUTES = 0x00400000, /**< Obsolete */
CK_STATESAVE_3DOBJECTRESERVED = 0x00800000, /**< Reserved for future use */
CK_STATESAVE_3DOBJECTRONLY = 0x00C00000, /**< Save only 3dObject specific datas */
@ -117,7 +117,7 @@ namespace LibCmo::CK2 {
/**
BodyPart
*/
enum class CK_STATESAVEFLAGS_BODYPART : uint32_t {
enum class CK_STATESAVEFLAGS_BODYPART : CKDWORD {
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 */
@ -131,7 +131,7 @@ namespace LibCmo::CK2 {
/**
Character
*/
enum class CK_STATESAVEFLAGS_CHARACTER : uint32_t {
enum class CK_STATESAVEFLAGS_CHARACTER : CKDWORD {
CK_STATESAVE_CHARACTERBODYPARTS = 0x00400000, /**< Obsolete */
CK_STATESAVE_CHARACTERKINECHAINS = 0x00800000, /**< Obsolete */
CK_STATESAVE_CHARACTERANIMATIONS = 0x01000000, /**< Obsolete */
@ -148,7 +148,7 @@ namespace LibCmo::CK2 {
/**
CURVE && Curve Point
*/
enum class CK_STATESAVEFLAGS_CURVE : uint32_t {
enum class CK_STATESAVEFLAGS_CURVE : CKDWORD {
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 */
@ -166,7 +166,7 @@ namespace LibCmo::CK2 {
/**
2dEntity
*/
enum class CK_STATESAVEFLAGS_2DENTITY : uint32_t {
enum class CK_STATESAVEFLAGS_2DENTITY : CKDWORD {
CK_STATESAVE_2DENTITYSRCSIZE = 0x00001000, /**< Save source size */
CK_STATESAVE_2DENTITYSIZE = 0x00002000, /**< Save size */
CK_STATESAVE_2DENTITYFLAGS = 0x00004000, /**< Save Flags */
@ -180,7 +180,7 @@ namespace LibCmo::CK2 {
/**
Sprite
*/
enum class CK_STATESAVEFLAGS_SPRITE : uint32_t {
enum class CK_STATESAVEFLAGS_SPRITE : CKDWORD {
CK_STATESAVE_SPRITECURRENTIMAGE = 0x00010000, /**< Save current image */
CK_STATESAVE_SPRITETRANSPARENT = 0x00020000, /**< Save transparency settings */
CK_STATESAVE_SPRITEBITMAPS = 0x00040000, /**< Obsolete */
@ -200,7 +200,7 @@ namespace LibCmo::CK2 {
/**
Sprite Text
*/
enum class CK_STATESAVEFLAGS_SPRITETEXT : uint32_t {
enum class CK_STATESAVEFLAGS_SPRITETEXT : CKDWORD {
CK_STATESAVE_SPRITETEXT = 0x01000000, /**< Save text */
CK_STATESAVE_SPRITEFONT = 0x02000000, /**< Save font settings */
CK_STATESAVE_SPRITETEXTCOLOR = 0x04000000, /**< Save text color */
@ -213,7 +213,7 @@ namespace LibCmo::CK2 {
/**
Sound
*/
enum class CK_STATESAVEFLAGS_SOUND : uint32_t {
enum class CK_STATESAVEFLAGS_SOUND : CKDWORD {
CK_STATESAVE_SOUNDFILENAME = 0x00001000, /**< Reserved for future use */
CK_STATESAVE_SOUNDRESERVED1 = 0x00002000, /**< Reserved for future use */
CK_STATESAVE_SOUNDRESERVED2 = 0x00004000, /**< Reserved for future use */
@ -228,7 +228,7 @@ namespace LibCmo::CK2 {
/**
Wave Sound
*/
enum class CK_STATESAVEFLAGS_WAVSOUND : uint32_t {
enum class CK_STATESAVEFLAGS_WAVSOUND : CKDWORD {
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..) */
@ -243,7 +243,7 @@ namespace LibCmo::CK2 {
/**
Wave Sound
*/
enum class CK_STATESAVEFLAGS_MIDISOUND : uint32_t {
enum class CK_STATESAVEFLAGS_MIDISOUND : CKDWORD {
CK_STATESAVE_MIDISOUNDFILE = 0x00100000, /**< Save sound filename */
CK_STATESAVE_MIDISOUNDDATA = 0x00200000, /**< Save midi data */
CK_STATESAVE_MIDISOUNDRESERVED2 = 0x00400000, /**< Reserved for future use */
@ -258,7 +258,7 @@ namespace LibCmo::CK2 {
/**
Place
*/
enum class CK_STATESAVEFLAGS_PLACE : uint32_t {
enum class CK_STATESAVEFLAGS_PLACE : CKDWORD {
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 */
@ -268,7 +268,7 @@ namespace LibCmo::CK2 {
/**
Level CKSaveObjectState will not save any data
*/
enum class CK_STATESAVEFLAGS_LEVEL : uint32_t {
enum class CK_STATESAVEFLAGS_LEVEL : CKDWORD {
CK_STATESAVE_LEVELRESERVED0 = 0x00001000, /**< Reserved for future use */
CK_STATESAVE_LEVELINACTIVEMAN = 0x00002000, /**< Reserved for future use */
CK_STATESAVE_LEVELDUPLICATEMAN = 0x00004000, /**< Reserved for future use */
@ -279,7 +279,7 @@ namespace LibCmo::CK2 {
/**
GROUP
*/
enum class CK_STATESAVEFLAGS_GROUP : uint32_t {
enum class CK_STATESAVEFLAGS_GROUP : CKDWORD {
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 */
@ -293,7 +293,7 @@ namespace LibCmo::CK2 {
/**
MESH CKSaveOjectSave will save all data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_MESH : uint32_t {
enum class CK_STATESAVEFLAGS_MESH : CKDWORD {
CK_STATESAVE_MESHRESERVED0 = 0x00001000, /**< Reserved for future use */
CK_STATESAVE_MESHFLAGS = 0x00002000, /**< Save flags */
CK_STATESAVE_MESHCHANNELS = 0x00004000, /**< Save Channels */
@ -312,7 +312,7 @@ namespace LibCmo::CK2 {
/**
PATCH MESH CKSaveOjectSave will save all data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_PATCHMESH : uint32_t {
enum class CK_STATESAVEFLAGS_PATCHMESH : CKDWORD {
CK_STATESAVE_PATCHMESHDATA = 0x00800000, /**< Obsolete */
CK_STATESAVE_PATCHMESHDATA2 = 0x01000000, /**< Obsolete */
CK_STATESAVE_PATCHMESHSMOOTH = 0x02000000, /**< Obsolete */
@ -324,7 +324,7 @@ namespace LibCmo::CK2 {
/**
Material
*/
enum class CK_STATESAVEFLAGS_MATERIAL : uint32_t {
enum class CK_STATESAVEFLAGS_MATERIAL : CKDWORD {
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 */
@ -339,7 +339,7 @@ namespace LibCmo::CK2 {
/**
Texture CKSaveOjectSave will save all relevant data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_TEXTURE : uint32_t {
enum class CK_STATESAVEFLAGS_TEXTURE : CKDWORD {
CK_STATESAVE_TEXAVIFILENAME = 0x00001000, /**< Save movie file name */
CK_STATESAVE_TEXCURRENTIMAGE = 0x00002000, /**< Save current slot */
CK_STATESAVE_TEXBITMAPS = 0x00004000, /**< Obsolete */
@ -359,7 +359,7 @@ namespace LibCmo::CK2 {
/**
2d CURVE && 2d Curve Point
*/
enum class CK_STATESAVEFLAGS_2DCURVE : uint32_t {
enum class CK_STATESAVEFLAGS_2DCURVE : CKDWORD {
CK_STATESAVE_2DCURVERESERVED0 = 0x00000010, /**< Reserved for future use */
CK_STATESAVE_2DCURVERESERVED4 = 0x00000020, /**< Reserved for future use */
CK_STATESAVE_2DCURVEFITCOEFF = 0x00000040, /**< Obsolete */
@ -380,7 +380,7 @@ namespace LibCmo::CK2 {
/**
Kinematic Chain
*/
enum class CK_STATESAVEFLAGS_KINEMATICCHAIN : uint32_t {
enum class CK_STATESAVEFLAGS_KINEMATICCHAIN : CKDWORD {
CK_STATESAVE_KINEMATICCHAINDATA = 0x00000010, /**< Save chain data */
CK_STATESAVE_KINEMATICCHAINRESERVED1 = 0x00000020, /**< Reserved for future use */
CK_STATESAVE_KINEMATICCHAINRESERVED2 = 0x00000040, /**< Reserved for future use */
@ -390,7 +390,7 @@ namespace LibCmo::CK2 {
/**
Animation
*/
enum class CK_STATESAVEFLAGS_ANIMATION : uint32_t {
enum class CK_STATESAVEFLAGS_ANIMATION : CKDWORD {
CK_STATESAVE_ANIMATIONDATA = 0x00000010, /**< Save Flags & Framerate data */
CK_STATESAVE_ANIMATIONRESERVED1 = 0x00000020, /**< Reserved for future use */
CK_STATESAVE_ANIMATIONLENGTH = 0x00000040, /**< Save animation Length */
@ -404,7 +404,7 @@ namespace LibCmo::CK2 {
/**
Keyed Anim
*/
enum class CK_STATESAVEFLAGS_KEYEDANIMATION : uint32_t {
enum class CK_STATESAVEFLAGS_KEYEDANIMATION : CKDWORD {
CK_STATESAVE_KEYEDANIMANIMLIST = 0x00001000, /**< Save list of object animations */
CK_STATESAVE_KEYEDANIMLENGTH = 0x00002000, /**< Obsolete */
CK_STATESAVE_KEYEDANIMPOSKEYS = 0x00004000, /**< Obsolete */
@ -423,7 +423,7 @@ namespace LibCmo::CK2 {
/**
Object Animation CKSaveOjectSave will save all relevant data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_OBJECTANIMATION : uint32_t {
enum class CK_STATESAVEFLAGS_OBJECTANIMATION : CKDWORD {
CK_STATESAVE_OBJANIMNEWDATA = 0x00001000, /**< Save all relevant data */
CK_STATESAVE_OBJANIMLENGTH = 0x00002000, /**< Not used */
CK_STATESAVE_OBJANIMPOSKEYS = 0x00004000, /**< Not used */
@ -447,7 +447,7 @@ namespace LibCmo::CK2 {
/**
IK Animation
*/
enum class CK_STATESAVEFLAGS_IKANIMATION : uint32_t {
enum class CK_STATESAVEFLAGS_IKANIMATION : CKDWORD {
CK_STATESAVE_IKANIMATIONDATA = 0x00001000, /**< Save IK data */
CK_STATESAVE_IKANIMATIONRESERVED2 = 0x00002000, /**< Reserved for future use */
CK_STATESAVE_IKANIMATIONRESERVED3 = 0x00004000, /**< Reserved for future use */
@ -462,7 +462,7 @@ namespace LibCmo::CK2 {
/**
BehaviorLink
*/
enum class CK_STATESAVEFLAGS_BEHAV_LINK : uint32_t {
enum class CK_STATESAVEFLAGS_BEHAV_LINK : CKDWORD {
CK_STATESAVE_BEHAV_LINK_CURDELAY = 0x00000004, /**< Obsolete */
CK_STATESAVE_BEHAV_LINK_IOS = 0x00000008, /**< Obsolete */
CK_STATESAVE_BEHAV_LINK_DELAY = 0x00000010, /**< Obsolete */
@ -475,7 +475,7 @@ namespace LibCmo::CK2 {
/**
BehaviorIO
*/
enum class CK_STATESAVEFLAGS_BEHAV_IO : uint32_t {
enum class CK_STATESAVEFLAGS_BEHAV_IO : CKDWORD {
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 */
@ -487,7 +487,7 @@ namespace LibCmo::CK2 {
/**
BehaviorPrototype
*/
enum class CK_STATESAVEFLAGS_PROTOTYPE : uint32_t {
enum class CK_STATESAVEFLAGS_PROTOTYPE : CKDWORD {
CK_STATESAVE_PROTORESERVED0 = 0x00000010, /**< Reserved for future use */
CK_STATESAVE_PROTORESERVED1 = 0x00000020, /**< Reserved for future use */
CK_STATESAVE_PROTOFLAGS = 0x00000040, /**< Save Flags */
@ -509,7 +509,7 @@ namespace LibCmo::CK2 {
/**
Behavior
*/
enum class CK_STATESAVEFLAGS_BEHAVIOR : uint32_t {
enum class CK_STATESAVEFLAGS_BEHAVIOR : CKDWORD {
CK_STATESAVE_BEHAVIORRESERVED0 = 0x00000010, /**< Reserved for internal use */
CK_STATESAVE_BEHAVIORNEWDATA = 0x00000020, /**< not used */
CK_STATESAVE_BEHAVIORFLAGS = 0x00000040, /**< not used */
@ -537,7 +537,7 @@ namespace LibCmo::CK2 {
/**
SCENE CKSaveOjectSave will save all relevant data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_SCENE : uint32_t {
enum class CK_STATESAVEFLAGS_SCENE : CKDWORD {
CK_STATESAVE_SCENERESERVED0 = 0x00001000, /**< Reserved for future use */
CK_STATESAVE_SCENERESERVED8 = 0x00002000, /**< Reserved for future use */
CK_STATESAVE_SCENEFLAGS = 0x00004000,
@ -559,7 +559,7 @@ namespace LibCmo::CK2 {
/**
ParameterIn
*/
enum class CK_STATESAVEFLAGS_PARAMETERIN : uint32_t {
enum class CK_STATESAVEFLAGS_PARAMETERIN : CKDWORD {
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 */
@ -575,7 +575,7 @@ namespace LibCmo::CK2 {
/**
ParameterLocal et ParameterOut
*/
enum class CK_STATESAVEFLAGS_PARAMETEROUT : uint32_t {
enum class CK_STATESAVEFLAGS_PARAMETEROUT : CKDWORD {
CK_STATESAVE_PARAMETEROUT_RESERVED0 = 0x00000010, /**< Reserved for future use */
CK_STATESAVE_PARAMETEROUT_DESTINATIONS = 0x00000020, /**< Save destinations */
CK_STATESAVE_PARAMETEROUT_VAL = 0x00000040, /**< Save value */
@ -587,7 +587,7 @@ namespace LibCmo::CK2 {
/**
Parameter Operation
*/
enum class CK_STATESAVEFLAGS_OPERATION : uint32_t {
enum class CK_STATESAVEFLAGS_OPERATION : CKDWORD {
CK_STATESAVE_OPERATIONRESERVED0 = 0x00000010, /**< Reserved for future use */
CK_STATESAVE_OPERATIONRESERVED1 = 0x00000020, /**< Reserved for future use */
CK_STATESAVE_OPERATIONINPUTS = 0x00000040,
@ -600,7 +600,7 @@ namespace LibCmo::CK2 {
/**
Synchro Object CKSaveOjectSave will save all relevant data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_SYNCHRO : uint32_t {
enum class CK_STATESAVEFLAGS_SYNCHRO : CKDWORD {
CK_STATESAVE_SYNCHRODATA = 0x00000010, /**< Save data */
CK_STATESAVE_SYNCHRORESERVED0 = 0x00000040, /**< Reserved for future use */
CK_STATESAVE_SYNCHRORESERVED1 = 0x00000080, /**< Reserved for future use */
@ -611,7 +611,7 @@ namespace LibCmo::CK2 {
/**
Grid
*/
enum class CK_STATESAVEFLAGS_GRID : uint32_t {
enum class CK_STATESAVEFLAGS_GRID : CKDWORD {
CK_STATESAVE_GRIDDATA = 0x00400000, /**< Save Grid Data */
CK_STATESAVE_GRIDRESERVED0 = 0x00800000, /**< Reserved for future use */
CK_STATESAVE_GRIDRESERVED1 = 0x01000000, /**< Reserved for future use */
@ -624,7 +624,7 @@ namespace LibCmo::CK2 {
/**
Layer (For Grids)
*/
enum class CK_STATESAVEFLAGS_LAYER : uint32_t {
enum class CK_STATESAVEFLAGS_LAYER : CKDWORD {
CK_STATESAVE_LAYERDATA = 0x00000010, /**< Save Layer Data */
CK_STATESAVE_LAYERRESERVED0 = 0x00800020, /**< Reserved for future use */
CK_STATESAVE_LAYERRESERVED1 = 0x00000040, /**< Reserved for future use */
@ -637,7 +637,7 @@ namespace LibCmo::CK2 {
/**
DataArray CKSaveOjectSave will save all relevant data and does not take flags into account
*/
enum class CK_STATESAVEFLAGS_DATAARRAY : uint32_t {
enum class CK_STATESAVEFLAGS_DATAARRAY : CKDWORD {
CK_STATESAVE_DATAARRAYFORMAT = 0x00001000, /**< Save format */
CK_STATESAVE_DATAARRAYDATA = 0x00002000, /**< Save array data */
CK_STATESAVE_DATAARRAYMEMBERS = 0x00004000, /**< Save members */
@ -646,7 +646,7 @@ namespace LibCmo::CK2 {
/**
SceneObjectDesc
*/
enum class CK_STATESAVEFLAGS_SCENEOBJECTDESC : uint32_t {
enum class CK_STATESAVEFLAGS_SCENEOBJECTDESC : CKDWORD {
CK_STATESAVE_SCENEOBJECTDESC = 0x00000010,
CK_STATESAVE_SCENEOBJECTRES1 = 0x00000020, /**< Reserved for future use */
CK_STATESAVE_SCENEOBJECTRES2 = 0x00000040, /**< Reserved for future use */

4
LibCmo/CK2/CKStateChunk.cpp
View File

@ -583,7 +583,7 @@ namespace LibCmo::CK2 {
}
}
bool CKStateChunk::ReadString(std::string* strl) {
bool CKStateChunk::ReadString(XContainer::XString* strl) {
if (strl == nullptr) return false;
// get byte based size
@ -594,7 +594,7 @@ namespace LibCmo::CK2 {
}
// read data
std::string cache;
XContainer::XString cache;
cache.resize(strByteSize);
if (!this->ReadByteData(cache.data(), strByteSize)) {
strl->clear();

4
LibCmo/CK2/CKStateChunk.hpp
View File

@ -158,8 +158,8 @@ namespace LibCmo::CK2 {
/// </summary>
/// <param name="strl"></param>
/// <returns></returns>
bool ReadString(std::string* strl);
inline bool ReadString(std::string& strl) {
bool ReadString(XContainer::XString* strl);
inline bool ReadString(XContainer::XString& strl) {
return ReadString(&strl);
}

79
LibCmo/CK2/CKStructs.hpp
View File

@ -1,79 +0,0 @@
#pragma once
#include "CKGlobals.hpp"
namespace LibCmo::CK2 {
// a stupid forward decl to remove something
/**
* @brief Storage class for filename extensions
*/
class CKFileExtension {
public:
CKFileExtension() : m_Data() {
std::memset(m_Data, 0, c_DataLen);
}
CKFileExtension(CKSTRING s) : CKFileExtension() {
SetExt(s);
}
CKFileExtension(const CKFileExtension& rhs) : CKFileExtension() {
std::memcpy(m_Data, rhs.m_Data, c_DataLen);
}
CKFileExtension(CKFileExtension&& rhs) : CKFileExtension() {
std::memmove(m_Data, rhs.m_Data, c_DataLen);
std::memset(rhs.m_Data, 0, c_DataLen);
}
CKFileExtension& operator=(const CKFileExtension& rhs) {
std::memcpy(m_Data, rhs.m_Data, c_DataLen);
return *this;
}
CKFileExtension& operator=(CKFileExtension&& rhs) {
std::memmove(m_Data, rhs.m_Data, c_DataLen);
std::memset(rhs.m_Data, 0, c_DataLen);
return *this;
}
void SetExt(CKSTRING s) {
if (s == nullptr) {
m_Data[0] = '\0';
} else {
if (s[0] == '.') ++s; // skip dot
size_t len = std::strlen(s);
if (len > (c_DataLen - 1)) len = c_DataLen - 1;
std::memcpy(m_Data, s, len);
}
}
CKSTRING GetExt() const {
return m_Data;
}
bool operator==(const CKFileExtension& rhs) const {
return CKStrEqualI(m_Data, rhs.m_Data);
}
protected:
static constexpr size_t c_DataLen = 4u;
CKCHAR m_Data[c_DataLen];
};
/**
* The struct describe the bitmap handler's infomation,
* including its GUID and supported file extension.
* This struct also will store some parameters related to bitmap handler,
* such as jpeg compress level and etc. But currently there are no
* such parameters.
*/
class CKBitmapProperties {
public:
CKBitmapProperties() :
m_ReaderGuid(), m_Ext() {}
CKBitmapProperties(const CKGUID& guid, CKSTRING ext) :
m_ReaderGuid(guid), m_Ext(ext) {}
LIBCMO_DEFAULT_COPY_MOVE(CKBitmapProperties);
CKGUID m_ReaderGuid; /**< CKGUID that uniquely identifies the reader that created this properties structure */
CKFileExtension m_Ext; /**< File Extension of the image being described by this structure */
};
}

217
LibCmo/CK2/CKTypes.hpp
View File

@ -5,11 +5,133 @@
#include <vector>
#include <cstring>
#include <cinttypes>
#include <compare>
// ========== Basic Types Section ==========
namespace LibCmo {
// Types.
// These types is general types used in every module.
// So we declare them in LibCmo, not LibCmo::CK2 to make sure every module can use it.
/**
* @brief General Const String Type. Encoding Unrelated.
*/
using CKSTRING = const char*;
/**
* @brief Changeble CKSTRING.
* @see CKSTRING
*/
using CKMUTSTRING = char*;
/**
* @brief The Representation of Single Character (1 byte). Encoding Unrelated.
* @remark
* + Only used with string process.
* + For memory representation and moving, use CKBYTE instead.
* @see CKBYTE
*/
using CKCHAR = char;
/**
* @brief Always Represent a Byte (1 byte, unsigned). Platform Independent.
* @remark
* + This type should only be used when representing memory data or position.
* + If you want to represent a char, or a sequence of chars, use CKCHAR instead.
* @see CKCHAR
*/
using CKBYTE = uint8_t;
/**
* @brief Always Represent a WORD (2 byte, unsigned). Platform Independent.
*/
using CKWORD = uint16_t;
/**
* @brief Always Represent a DWORD (4 byte, unsigned). Platform Independent.
* @see CKINT
*/
using CKDWORD = uint32_t;
/**
* @brief Always Represent a QWORD (8 byte, unsigned). Platform Independent.
*/
using CKQWORD = uint64_t;
/**
* @brief The Int type used in LibCmo.
* @remark
* + All 'int' type in original Virtools SDK should be replaced with CKINT in this project if needed.
* + This type also can be seen as the equvalent of signed CKDWORD.
* @see CKDWORD
*/
using CKINT = int32_t;
/**
* @brief Always Represent a float (32 bit). Platform Independent.
*/
using CKFLOAT = float;
/**
* @brief Always Represent a double (64 bit). Platform Independent.
*/
using CKDOUBLE = double;
/**
* @brief The bool type used by LibCmo.
* Generally it is just C++ bool.
*/
using CKBOOL = bool;
/**
* @brief The True value of CKBOOL.
*/
constexpr CKBOOL CKTRUE = true;
/**
* @brief The False value of CKBOOL.
*/
constexpr CKBOOL CKFALSE = false;
/**
* @brief Represent a x86 Platform Pointer.
* @remark
* + This type only can be used when replacing pointer in old Virtools struct / class.
* + Due to Virtools shitty design, in some cases we need read data with x86 memory layout from file.
* So we use this type to replace native pointer in struct existed in Virtools SDK to make sure this
* program can run perfectly on x64 and more architectures.
* + A example can be found in CKTexture::Load().
*/
using CKPTR = uint32_t;
// Format constants for the std::fprintf family of functions
#define PRI_CKSTRING "s"
#define PRI_CKCHAR "c"
#define PRIuCKBYTE PRIu8
#define PRIuCKWORD PRIu16
#define PRIuCKDWORD PRIu32
#define PRIuCKQWORD PRIu64
#define PRIxCKBYTE PRIx8
#define PRIxCKWORD PRIx16
#define PRIxCKDWORD PRIx32
#define PRIxCKQWORD PRIx64
#define PRIXCKBYTE PRIX8
#define PRIXCKWORD PRIX16
#define PRIXCKDWORD PRIX32
#define PRIXCKQWORD PRIX64
#define PRIiCKINT PRIi32
#define PRIxCKPTR PRIx32
#define PRIXCKPTR PRIX32
/*
The convenient sizeof which return CKDWORD, not size_t.
*/
#define CKSizeof(_Ty) (static_cast<LibCmo::CKDWORD>(sizeof(_Ty)))
}
// ========== CK2 Section ==========
/**
* @brief The CK2 part of LibCmo.
* These classes are prefixed with CK in original Virtools SDK.
*/
namespace LibCmo::CK2 {
/**
@ -25,9 +147,9 @@ namespace LibCmo::CK2 {
is no garanty that this ID will be the same when a level is saved and loaded back again.
@see CKObject::GetID, CKContext::GetObject
*/
using CK_ID = uint32_t;
using CK_ID = CKDWORD;
enum class CKERROR : int32_t {
enum class CKERROR : CKINT {
CKERR_OK = 0, /**< Operation successful */
CKERR_INVALIDPARAMETER = -1, /**< One of the parameter passed to the function was invalid */
CKERR_INVALIDPARAMETERTYPE = -2, /**< One of the parameter passed to the function was invalid */
@ -91,7 +213,7 @@ namespace LibCmo::CK2 {
objects, etc..
@see CKObject::GetClassID, CKIsChildClassOf, Class Identifiers
*/
enum class CK_CLASSID : int32_t {
enum class CK_CLASSID : CKINT {
CKCID_OBJECT = 1,
CKCID_PARAMETERIN = 2,
CKCID_PARAMETEROPERATION = 4,
@ -164,37 +286,16 @@ namespace LibCmo::CK2 {
// ========== Type Definition ==========
// type define
using CKMUTSTRING = char*;
using CKSTRING = const char*;
using CKCHAR = char;
using CKBYTE = uint8_t;
using CKDWORD = uint32_t;
using CKWORD = uint16_t;
using CKINT = int32_t;
using CKParameterType = int32_t;
using CKOperationType = int32_t;
using CKMessageType = int32_t;
using CKAttributeType = int32_t;
using CKAttributeCategory = int32_t;
// type print style define
#define PRIuCKID PRIu32
#define PRIiCKERROR PRIi32
#define PRIiCLASSID PRIi32
#define PRIuCKBYTE PRIu8
#define PRIuCKDWORD PRIu32
#define PRIuCKWORD PRIu16
#define PRIxCKBYTE PRIx8
#define PRIxCKDWORD PRIx32
#define PRIxCKWORD PRIx16
#define PRIXCKBYTE PRIX8
#define PRIXCKDWORD PRIX32
#define PRIXCKWORD PRIX16
#define PRIiCKINT PRIi32
using CKParameterType = CKINT;
using CKOperationType = CKINT;
using CKMessageType = CKINT;
using CKAttributeType = CKINT;
using CKAttributeCategory = CKINT;
// format constant
#define PRIuCKID PRIuCKDWORD
#define PRIiCKERROR PRIiCKINT
#define PRIiCLASSID PRIiCKINT
// ========== Class List ==========
// Objects and derivated classes
@ -300,7 +401,6 @@ namespace LibCmo::CK2 {
class CKFileWriter;
class CKFileVisitor;
/**
@brief Global Unique Identifier Struture.
@remark
@ -331,40 +431,15 @@ namespace LibCmo::CK2 {
return *this;
}
bool operator ==(const CKGUID& rhs) const {
auto operator<=>(const CKGUID& rhs) const {
auto cmp = this->d1 <=> rhs.d1;
if (cmp != 0)
return cmp;
return this->d2 <=> rhs.d2;
}
bool operator==(const CKGUID& rhs) const {
return ((this->d1 == rhs.d1) && (this->d2 == rhs.d2));
}
bool operator !=(const CKGUID& rhs) const {
return ((this->d1 != rhs.d1) || (this->d2 != rhs.d2));
}
bool operator <(const CKGUID& rhs) const {
if (this->d1 < rhs.d1) {
return true;
}
if (this->d1 == rhs.d1) {
return (this->d2 < rhs.d2);
}
return false;
}
bool operator <=(const CKGUID& rhs) const {
return (this->d1 <= rhs.d1);
}
bool operator >(const CKGUID& rhs) const {
if (this->d1 > rhs.d1) {
return true;
}
if (this->d1 == rhs.d1) {
return (this->d2 > rhs.d2);
}
return false;
}
bool operator >=(const CKGUID& rhs) const {
return (this->d1 >= rhs.d1);
}
};
}

7
LibCmo/CK2/DataHandlers/CKBitmapHandler.cpp
View File

@ -1,7 +1,4 @@
#include "CKBitmapHandler.hpp"
#include "stb_image.h"
#include "stb_image_write.h"
#include "stb_image_resize.h"
namespace LibCmo::CK2::DataHandlers {
@ -14,7 +11,7 @@ namespace LibCmo::CK2::DataHandlers {
The data is placed in buffer with BGRA order.
*/
static void ABGRToARGB(CK2::CKDWORD count, const void* _abgr, void* _argb) {
static void ABGRToARGB(CKDWORD count, const void* _abgr, void* _argb) {
const char* abgr = reinterpret_cast<const char*>(_abgr);
char* argb = reinterpret_cast<char*>(_argb);
// copy R
@ -55,7 +52,7 @@ namespace LibCmo::CK2::DataHandlers {
);
}
static void ARGBToABGR(CK2::CKDWORD count, const void* _argb, void* _abgr) {
static void ARGBToABGR(CKDWORD count, const void* _argb, void* _abgr) {
const char* argb = reinterpret_cast<const char*>(_argb);
char* abgr = reinterpret_cast<char*>(_abgr);
// copy R

10
LibCmo/CK2/MgrImpls/CKBaseManager.hpp
View File

@ -36,9 +36,9 @@ namespace LibCmo::CK2::MgrImpls {
class CKBaseManager {
public:
CKBaseManager(CKContext* ctx, CKGUID guid, CKSTRING name) :
m_ManagerGuid(guid),
m_ManagerName(name),
m_Context(ctx) {}
m_ManagerGuid(guid), m_ManagerName(), m_Context(ctx) {
XContainer::NSXString::FromCKSTRING(m_ManagerName, name);
}
virtual ~CKBaseManager() {}
LIBCMO_DISABLE_COPY_MOVE(CKBaseManager);
@ -77,7 +77,7 @@ namespace LibCmo::CK2::MgrImpls {
```
*/
CKSTRING GetName() {
return m_ManagerName.toCKSTRING();
return XContainer::NSXString::ToCKSTRING(m_ManagerName);
}
/**
@ -155,7 +155,7 @@ namespace LibCmo::CK2::MgrImpls {
protected:
CKGUID m_ManagerGuid; ///> Manager GUID
TypeHelper::MKString m_ManagerName; ///> Manager Name
XContainer::XString m_ManagerName; ///> Manager Name
CKContext* m_Context; ///> A pointer to the CKContext on which this manager is valid.
};

12
LibCmo/CK2/MgrImpls/CKPathManager.cpp
View File

@ -32,18 +32,18 @@ namespace LibCmo::CK2::MgrImpls {
}
}
std::string CKPathManager::GetTempFolder() {
std::string result;
XContainer::XString CKPathManager::GetTempFolder() {
XContainer::XString result;
EncodingHelper::StdPathToU8Path(result, this->m_TempFolder);
return result;
}
std::string CKPathManager::GetTempFilePath(CKSTRING u8_filename) {
XContainer::XString CKPathManager::GetTempFilePath(CKSTRING u8_filename) {
std::filesystem::path stdfilename;
EncodingHelper::U8PathToStdPath(stdfilename, u8_filename);
auto realfile = this->m_TempFolder / stdfilename;
std::string result;
XContainer::XString result;
EncodingHelper::StdPathToU8Path(result, realfile);
return result;
}
@ -64,7 +64,7 @@ namespace LibCmo::CK2::MgrImpls {
m_ExtraPathes.clear();
}
bool CKPathManager::ResolveFileName(std::string& u8_filename) {
bool CKPathManager::ResolveFileName(XContainer::XString& u8_filename) {
std::filesystem::path filepath;
EncodingHelper::U8PathToStdPath(filepath, u8_filename.c_str());
@ -94,7 +94,7 @@ namespace LibCmo::CK2::MgrImpls {
return false;
}
void CKPathManager::GetExtension(std::string& u8path) {
void CKPathManager::GetExtension(XContainer::XString& u8path) {
std::filesystem::path filepath;
EncodingHelper::U8PathToStdPath(filepath, u8path.c_str());

8
LibCmo/CK2/MgrImpls/CKPathManager.hpp
View File

@ -22,13 +22,13 @@ namespace LibCmo::CK2::MgrImpls {
* @brief Get current temp folder.
* @return
*/
std::string GetTempFolder();
XContainer::XString GetTempFolder();
/**
* @brief Get the path of temp file.
* @param u8_filename The relative path of file.
* @return The path of given path based on temp folder.
*/
std::string GetTempFilePath(CKSTRING u8_filename);
XContainer::XString GetTempFilePath(CKSTRING u8_filename);
/**
* @brief Add extra path for ResolveFileName
@ -51,13 +51,13 @@ namespace LibCmo::CK2::MgrImpls {
* + Virtools temp folder.
* @return true if success
*/
bool ResolveFileName(std::string& u8_filename);
bool ResolveFileName(XContainer::XString& u8_filename);
/**
* @brief Returns the file extension including period (.)
* @param u8path[inout] The given path. overwritten by the gotten extension. set to blank when failed.
*/
void GetExtension(std::string& u8path);
void GetExtension(XContainer::XString& u8path);
protected:
std::filesystem::path m_TempFolder;

2
LibCmo/CK2/ObjImpls/CKMaterial.hpp
View File

@ -26,7 +26,7 @@ namespace LibCmo::CK2::ObjImpls {
VxMath::VxColor m_Ambient;
VxMath::VxColor m_Specular;
VxMath::VxColor m_Emissive;
float m_SpecularPower;
CKFLOAT m_SpecularPower;
std::array<CKTexture*, 4> m_Textures;
CKDWORD m_TextureBorderColor;

2
LibCmo/CK2/ObjImpls/CKMesh.cpp
View File

@ -141,7 +141,7 @@ namespace LibCmo::CK2::ObjImpls {
return m_VertexSpecularColor.data();
}
float* CKMesh::GetVertexWeights() {
CKFLOAT* CKMesh::GetVertexWeights() {
return m_VertexWeight.data();
}

10
LibCmo/CK2/ObjImpls/CKMesh.hpp
View File

@ -36,7 +36,7 @@ namespace LibCmo::CK2::ObjImpls {
VxMath::VxVector2* GetVertexUVs();
CKDWORD* GetVertexColors();
CKDWORD* GetVertexSpecularColors();
float* GetVertexWeights();
CKFLOAT* GetVertexWeights();
// ===== Material Slot Section =====
public:
@ -77,10 +77,10 @@ namespace LibCmo::CK2::ObjImpls {
protected:
enum class VertexSaveFlags : CKDWORD {
SingleColor = 0x1u, /**< if not set, the VertexColor is a list<EFBFBD><EFBFBD> otherwise a single global CKDWORD.*/
SingleSpecularColor = 0x2u, /**< if not set, the VertexSpecularColor is a list<EFBFBD><EFBFBD> otherwise a single global CKDWORD. */
SingleColor = 0x1u, /**< if not set, the VertexColor is a list, otherwise a single global CKDWORD.*/
SingleSpecularColor = 0x2u, /**< if not set, the VertexSpecularColor is a list, otherwise a single global CKDWORD. */
NoNormal = 0x4u, /**< if set, there are no normal data for vertex. */
SingleUV = 0x8u, /**< if not set, the VertexUV is a list<EFBFBD><EFBFBD> otherwise a single global VxVertex2. */
SingleUV = 0x8u, /**< if not set, the VertexUV is a list, otherwise a single global VxVertex2. */
NoPos = 0x10u, /**< if set, there are no position data for vertex. */
};
struct FaceData_t {
@ -118,7 +118,7 @@ namespace LibCmo::CK2::ObjImpls {
XContainer::XArray<VxMath::VxVector2> m_VertexUV;
XContainer::XArray<CKDWORD> m_VertexColor;
XContainer::XArray<CKDWORD> m_VertexSpecularColor;
XContainer::XArray<float> m_VertexWeight;
XContainer::XArray<CKFLOAT> m_VertexWeight;
XContainer::XArray<CKMaterial*> m_MaterialSlot;

6
LibCmo/CK2/ObjImpls/CKObject.hpp
View File

@ -50,10 +50,10 @@ namespace LibCmo::CK2::ObjImpls {
return m_ID;
}
CKSTRING GetName(void) {
return m_Name.toCKSTRING();
return XContainer::NSXString::ToCKSTRING(m_Name);
}
void SetName(CKSTRING u8_name) {
m_Name = u8_name;
XContainer::NSXString::FromCKSTRING(m_Name, u8_name);
}
CK_OBJECT_FLAGS GetObjectFlags(void) {
return m_ObjectFlags;
@ -75,7 +75,7 @@ namespace LibCmo::CK2::ObjImpls {
protected:
CK_ID m_ID;
TypeHelper::MKString m_Name;
XContainer::XString m_Name;
CK_OBJECT_FLAGS m_ObjectFlags;
CKContext* m_Context;
};

38
LibCmo/CK2/ObjImpls/CKTexture.cpp
View File

@ -25,38 +25,38 @@ namespace LibCmo::CK2::ObjImpls {
}m_Ext;
struct {
// fake VxImageDescEx
CK2::CKINT Size; ///< Size of the structure
CK2::CKDWORD Flags; ///< Reserved for special formats (such as compressed ) 0 otherwise
CKINT Size; ///< Size of the structure
CKDWORD Flags; ///< Reserved for special formats (such as compressed ) 0 otherwise
CK2::CKINT Width; ///< Width in pixel of the image
CK2::CKINT Height; ///< Height in pixel of the image
CKINT Width; ///< Width in pixel of the image
CKINT Height; ///< Height in pixel of the image
union {
CK2::CKINT BytesPerLine; ///< Pitch (width in bytes) of the image
CK2::CKINT TotalImageSize; ///< For compressed image (DXT1...) the total size of the image
CKINT BytesPerLine; ///< Pitch (width in bytes) of the image
CKINT TotalImageSize; ///< For compressed image (DXT1...) the total size of the image
};
CK2::CKINT BitsPerPixel; ///< Number of bits per pixel
CKINT BitsPerPixel; ///< Number of bits per pixel
union {
CK2::CKDWORD RedMask; ///< Mask for Red component
CK2::CKDWORD BumpDuMask; ///< Mask for Bump Du component
CKDWORD RedMask; ///< Mask for Red component
CKDWORD BumpDuMask; ///< Mask for Bump Du component
};
union {
CK2::CKDWORD GreenMask; ///< Mask for Green component
CK2::CKDWORD BumpDvMask; ///< Mask for Bump Dv component
CKDWORD GreenMask; ///< Mask for Green component
CKDWORD BumpDvMask; ///< Mask for Bump Dv component
};
union {
CK2::CKDWORD BlueMask; ///< Mask for Blue component
CK2::CKDWORD BumpLumMask; ///< Mask for Luminance component
CKDWORD BlueMask; ///< Mask for Blue component
CKDWORD BumpLumMask; ///< Mask for Luminance component
};
CK2::CKDWORD AlphaMask; ///< Mask for Alpha component
CKDWORD AlphaMask; ///< Mask for Alpha component
CK2::CKWORD BytesPerColorEntry; ///< ColorMap Stride
CK2::CKWORD ColorMapEntries; ///< If other than 0 image is palletized
CKWORD BytesPerColorEntry; ///< ColorMap Stride
CKWORD ColorMapEntries; ///< If other than 0 image is palletized
/*CK2::CKBYTE**/CK2::CKDWORD ColorMap; ///< Palette colors
/*CK2::CKBYTE**/CK2::CKDWORD Image; ///< Image
/*CKBYTE**/CKPTR ColorMap; ///< Palette colors
/*CKBYTE**/CKPTR Image; ///< Image
}m_Format;
/*void**/CK2::CKDWORD m_Data;
/*void**/CKPTR m_Data;
};
CKTexture::CKTexture(CKContext* ctx, CK_ID ckid, CKSTRING name) :