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-02-26 21:48:03 +08:00
parent e450fa532d
commit 0519a557b8
32 changed files with 846 additions and 618 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
LibCmo/CKDefines.hpp
View File

@ -4,34 +4,133 @@
#include <vector>
namespace LibCmo {
namespace CK2 {
using CKINT = int32_t;
using CK_ID = uint32_t;
using CKDWORD = uint32_t;
using CKWORD = uint16_t;
using CKBYTE = uint8_t;
using CKBOOL = int32_t;
using CKMUTSTRING = char*;
using CKSTRING = const char*;
// some important type define
using XString = std::string;
using XBitArray = std::vector<bool>;
template<typename T>
using XArray = std::vector<T>;
using XIntArray = std::vector<int32_t>;
template<typename T>
using XClassArray = std::vector<T>;
//using CKObjectArray = std::vector<CKObject*>;
using CK_ID = uint32_t;
struct CKGUID {
union {
struct {
CKDWORD d1, d2;
};
CKDWORD d[2];
};
CKGUID(CKDWORD gd1 = 0, CKDWORD gd2 = 0) { d[0] = gd1; d[1] = gd2; }
};
using CKDWORD = uint32_t;
using CKWORD = uint16_t;
using CKBYTE = uint8_t;
using CKBOOL = int32_t;
using CKINT = int32_t;
using CKMUTSTRING = char*;
using CKSTRING = const char*;
using XString = std::string;
using XBitArray = std::vector<bool>;
template<typename T>
using XArray = std::vector<T>;
using XIntArray = std::vector<int32_t>;
template<typename T>
using XClassArray = std::vector<T>;
//using CKObjectArray = std::vector<CKObject*>;
// forward decl for some CKObjects
namespace CKObjectImplements {
class CKObject;
class CKParameterIn;
class CKParameter;
class CKParameterOut;
class CKParameterLocal;
class CKParameterOperation;
class CKBehaviorLink;
class CKBehaviorIO;
class CKSceneObject;
class CKBehavior;
class CKBeObject;
class CKScene;
class CKLevel;
class CKPlace;
class CKGroup;
class CKMaterial;
class CKTexture;
class CKMesh;
class CKDataArray;
class CKRenderObject;
class CK3dEntity;
class CK3dObject;
}
// forward decl for some CKManagers
namespace CKManagerImplements {
class CKBaseManager;
class CKAttributeManager;
}
// forward decl for some important CK2 classes
class CKMinContext;
class CKStateChunk;
class CKFile;
namespace CKFileData {
class ShallowDocument;
class DeepDocument;
class HybridDocument;
}
// useful struct define
struct CKGUID {
union {
struct {
CKDWORD d1, d2;
};
CKDWORD d[2];
};
CKGUID(CKDWORD gd1 = 0, CKDWORD gd2 = 0) { d[0] = gd1; d[1] = gd2; }
};
}
namespace VxMath {
// forward decl for some important VxMath classes
class VxMemoryMappedFile;
struct VxVector {
union {
struct {
float x, y, z;
};
float v[3];
};
VxVector() : x(0.0f), y(0.0f), z(0.0f) { ; }
VxVector(float f) : x(f), y(f), z(f) { ; }
VxVector(float _x, float _y, float _z) : x(_x), y(_y), z(_z) { ; }
VxVector(const float f[3]) : x(f[0]), y(f[1]), z(f[2]) { ; }
};
struct VxQuaternion {
union {
struct {
VxVector axis;
float angle;
};
struct {
float x, y, z, w;
};
float v[4];
};
VxQuaternion() : x(0.0f), y(0.0f), z(0.0f), w(1.0f) { ; }
VxQuaternion(float X, float Y, float Z, float W) : x(X), y(Y), z(Z), w(W) { ; }
};
struct VxMatrix {
float m_Data[4][4];
VxMatrix() : m_Data() {
memset(m_Data, 0, sizeof(m_Data));
m_Data[0][0] = m_Data[1][1] = m_Data[2][2] = m_Data[3][3] = 1.0f;
}
VxMatrix(float m[4][4]) : m_Data() { std::memcpy(m_Data, m, sizeof(m_Data)); }
};
}
}

70
LibCmo/CKEnums.hpp
View File

@ -1,28 +1,9 @@
#pragma once
#include <type_traits>
#include <cinttypes>
#include <cstdint>
#include <cstdarg>
namespace LibCmo {
namespace EnumsHelper {
template<typename TEnum>
inline TEnum FlagEnumAdd(TEnum e, ...) {
TEnum result = e;
va_list argptr;
va_start(argptr, e);
result = static_cast<TEnum>(static_cast<std::underlying_type_t<TEnum>>(result) | static_cast<std::underlying_type_t<TEnum>>(va_arg(argptr, TEnum)));
va_end(argptr);
return result;
}
template<typename TEnum>
inline bool FlagEnumHas(TEnum e, TEnum probe) {
return static_cast<bool>(static_cast<std::underlying_type_t<TEnum>>(e) & static_cast<std::underlying_type_t<TEnum>>(probe));
}
}
namespace LibCmo::CK2 {
enum class CK_CLASSID : uint32_t {
CKCID_OBJECT = 1,
@ -150,14 +131,14 @@ namespace LibCmo {
CKERR_INVALIDANIMATION = -123
};
enum class CK_FILE_WRITEMODE : int32_t {
enum class CK_FILE_WRITEMODE : uint32_t {
CKFILE_UNCOMPRESSED = 0,
CKFILE_CHUNKCOMPRESSED_OLD = 1,
CKFILE_EXTERNALTEXTURES_OLD = 2,
CKFILE_FORVIEWER = 4,
CKFILE_WHOLECOMPRESSED = 8
};
enum class CK_LOAD_FLAGS : int32_t {
enum class CK_LOAD_FLAGS : uint32_t {
CK_LOAD_ANIMATION = 1 << 0,
CK_LOAD_GEOMETRY = 1 << 1,
CK_LOAD_DEFAULT = CK_LOAD_GEOMETRY | CK_LOAD_ANIMATION,
@ -169,13 +150,13 @@ namespace LibCmo {
CK_LOAD_CHECKDEPENDENCIES = 1 << 7,
CK_LOAD_ONLYBEHAVIORS = 1 << 8
};
enum class CK_FO_OPTIONS : int32_t {
enum class CK_FO_OPTIONS : uint32_t {
CK_FO_DEFAULT = 0,
CK_FO_RENAMEOBJECT,
CK_FO_REPLACEOBJECT,
CK_FO_DONTLOADOBJECT
};
enum class CK_PLUGIN_TYPE : int32_t {
enum class CK_PLUGIN_TYPE : uint32_t {
CKPLUGIN_BITMAP_READER = 0,
CKPLUGIN_SOUND_READER = 1,
CKPLUGIN_MODEL_READER = 2,
@ -185,7 +166,7 @@ namespace LibCmo {
CKPLUGIN_MOVIE_READER = 6,
CKPLUGIN_EXTENSION_DLL = 7
};
enum class CK_STATECHUNK_DATAVERSION : int32_t {
enum class CK_STATECHUNK_DATAVERSION : uint32_t {
CHUNKDATA_OLDVERSION = 0,
CHUNKDATA_BASEVERSION = 1,
CHUNK_WAVESOUND_VERSION2 = 2,
@ -199,14 +180,14 @@ namespace LibCmo {
CHUNK_DEV_2_1 = 10,
CHUNKDATA_CURRENTVERSION = CHUNK_DEV_2_1
};
enum class CK_STATECHUNK_CHUNKVERSION : int32_t {
enum class CK_STATECHUNK_CHUNKVERSION : uint32_t {
CHUNK_VERSIONBASE = 0,
CHUNK_VERSION1 = 4,
CHUNK_VERSION2 = 5,
CHUNK_VERSION3 = 6,
CHUNK_VERSION4 = 7
};
enum class CK_STATECHUNK_CHUNKOPTIONS : int32_t {
enum class CK_STATECHUNK_CHUNKOPTIONS : uint32_t {
CHNK_OPTION_IDS = 0x01,
CHNK_OPTION_MAN = 0x02,
CHNK_OPTION_CHN = 0x04,
@ -216,5 +197,40 @@ namespace LibCmo {
CHNK_DONTDELETE_PTR = 0x40,
CHNK_DONTDELETE_PARSER = 0x80
};
enum class CK_OBJECT_FLAGS : uint32_t {
CK_OBJECT_INTERFACEOBJ = 0x00000001,
CK_OBJECT_PRIVATE = 0x00000002,
CK_OBJECT_INTERFACEMARK = 0x00000004,
CK_OBJECT_FREEID = 0x00000008,
CK_OBJECT_TOBEDELETED = 0x00000010,
CK_OBJECT_NOTTOBESAVED = 0x00000020,
CK_OBJECT_VISIBLE = 0x00000040,
CK_OBJECT_NAMESHARED = 0x00000080,
CK_OBJECT_DYNAMIC = 0x00000108,
CK_OBJECT_HIERACHICALHIDE = 0x00000200,
CK_OBJECT_UPTODATE = 0x00000400,
CK_OBJECT_TEMPMARKER = 0x00000800,
CK_OBJECT_ONLYFORFILEREFERENCE = 0x00001000,
CK_OBJECT_NOTTOBEDELETED = 0x00002000,
CK_OBJECT_APPDATA = 0x00004000,
CK_OBJECT_SINGLEACTIVITY = 0x00008000,
CK_OBJECT_LOADSKIPBEOBJECT = 0x00010000,
CK_OBJECT_NOTTOBELISTEDANDSAVED = 0x00000023,
CK_PARAMETEROUT_SETTINGS = 0x00400000,
CK_PARAMETEROUT_PARAMOP = 0x00800000,
CK_PARAMETERIN_DISABLED = 0x01000000,
CK_PARAMETERIN_THIS = 0x02000000,
CK_PARAMETERIN_SHARED = 0x04000000,
CK_PARAMETEROUT_DELETEAFTERUSE = 0x08000000,
CK_OBJECT_PARAMMASK = 0x0FC00000,
CK_BEHAVIORIO_IN = 0x10000000,
CK_BEHAVIORIO_OUT = 0x20000000,
CK_BEHAVIORIO_ACTIVE = 0x40000000,
CK_OBJECT_IOTYPEMASK = 0x30000000,
CK_OBJECT_IOMASK = 0xF0000000,
CKBEHAVIORLINK_RESERVED = 0x10000000,
CKBEHAVIORLINK_ACTIVATEDLASTFRAME = 0x20000000,
CK_OBJECT_BEHAVIORLINKMASK = 0x30000000
};
}

34
LibCmo/CKFile.cpp
View File

@ -1,7 +1,9 @@
#include "CKFile.hpp"
#include "CKStateChunk.hpp"
#include "CKMinContext.hpp"
#include <cstdarg>
namespace LibCmo {
namespace LibCmo::CK2 {
#pragma region CKBufferParser
@ -29,12 +31,12 @@ namespace LibCmo {
#pragma region CKFileObject
LibCmo::CKFileObject::CKFileObject() :
Data(nullptr) {
CKFileObject::CKFileObject() :
Data(nullptr) {
;
}
LibCmo::CKFileObject::~CKFileObject() {
CKFileObject::~CKFileObject() {
;
}
@ -60,30 +62,34 @@ namespace LibCmo {
#pragma endregion
namespace CKFileData {
#pragma region ShallowDocument
LibCmo::CKFileData::ShallowDocument::ShallowDocument() {
this->m_IndexByClassId.resize(static_cast<size_t>(CK_CLASSID::CKCID_MAXCLASSID));
}
ShallowDocument::ShallowDocument() {
this->m_IndexByClassId.resize(static_cast<size_t>(CK_CLASSID::CKCID_MAXCLASSID));
}
LibCmo::CKFileData::ShallowDocument::~ShallowDocument() {
ShallowDocument::~ShallowDocument() {
}
}
#pragma endregion
#pragma region DeepDocument
LibCmo::CKFileData::DeepDocument::DeepDocument() {
this->m_IndexByClassId.resize(static_cast<size_t>(CK_CLASSID::CKCID_MAXCLASSID));
}
DeepDocument::DeepDocument() {
this->m_IndexByClassId.resize(static_cast<size_t>(CK_CLASSID::CKCID_MAXCLASSID));
}
LibCmo::CKFileData::DeepDocument::~DeepDocument() {
DeepDocument::~DeepDocument() {
}
}
#pragma endregion
}
#pragma region CKFile Misc
CKFile::CKFile(CKMinContext* ctx) :

12
LibCmo/CKFile.hpp
View File

@ -3,11 +3,7 @@
#include "CKDefines.hpp"
#include "CKEnums.hpp"
#include "VxMemoryMappedFile.hpp"
#include "CKStateChunk.hpp"
#include "CKMinContext.hpp"
namespace LibCmo {
namespace LibCmo::CK2 {
class CKBufferParser {
private:
@ -24,11 +20,11 @@ namespace LibCmo {
inline const void* GetPtr(void) { return (this->m_MemBegin + m_MemPos); }
inline void Read(void* data, size_t data_size) {
memcpy(data, (this->m_MemBegin + m_MemPos), data_size);
std::memcpy(data, (this->m_MemBegin + m_MemPos), data_size);
this->m_MemPos += data_size;
}
inline void Write(const void* data, size_t data_size) {
memcpy((this->m_MemBegin + m_MemPos), data, data_size);
std::memcpy((this->m_MemBegin + m_MemPos), data, data_size);
this->m_MemPos += data_size;
}
inline void* GetBase(void) { return this->m_MemBegin; }
@ -158,7 +154,7 @@ namespace LibCmo {
int32_t m_SaveIDMax;
CKFileInfo m_FileInfo;
XArray<ObjsImpl::CKObject*> m_Objects;
XArray<CKObjectImplements::CKObject*> m_Objects;
XClassArray<XIntArray> m_IndexByClassId;
XClassArray<XString> m_IncludedFiles;
private:

15
LibCmo/CKFileReader.cpp
View File

@ -1,8 +1,11 @@
#include "CKFile.hpp"
#include "CKGlobals.hpp"
#include "CKStateChunk.hpp"
#include "VxMemoryMappedFile.hpp"
#include "CKMinContext.hpp"
#include <memory>
namespace LibCmo {
namespace LibCmo::CK2 {
/*
* NOTE:
@ -17,7 +20,7 @@ namespace LibCmo {
// check file and open memory
if (u8_filename == nullptr) return CKERROR::CKERR_INVALIDPARAMETER;
std::unique_ptr<VxMemoryMappedFile> mappedFile(new(std::nothrow) VxMemoryMappedFile(u8_filename));
std::unique_ptr<VxMath::VxMemoryMappedFile> mappedFile(new(std::nothrow) VxMath::VxMemoryMappedFile(u8_filename));
if (mappedFile == nullptr) {
this->m_MinCtx->Printf("Out of memory when creating Memory File.");
return CKERROR::CKERR_OUTOFMEMORY;
@ -54,7 +57,7 @@ namespace LibCmo {
// ========== read header ==========
// check header size
if (parser->GetSize() < sizeof(CKRawFileInfo)) return CKERROR::CKERR_INVALIDFILE;
if (memcmp(parser->GetPtr(), "Nemo Fi", sizeof(CKRawFileInfo::NeMo))) return CKERROR::CKERR_INVALIDFILE;
if (std::memcmp(parser->GetPtr(), "Nemo Fi", sizeof(CKRawFileInfo::NeMo))) return CKERROR::CKERR_INVALIDFILE;
// read header
CKRawFileInfo rawHeader;
parser->Read(&rawHeader, sizeof(CKRawFileInfo));
@ -138,7 +141,7 @@ namespace LibCmo {
if (namelen != 0) {
name_conv.resize(namelen);
parser->Read(name_conv.data(), namelen);
m_MinCtx->GetUtf8ObjectName(name_conv, fileobj.Name);
m_MinCtx->GetUtf8String(name_conv, fileobj.Name);
}
}
}
@ -325,7 +328,7 @@ namespace LibCmo {
// read filename
if (filenamelen != 0) {
parser->Read(name_conv.data(), filenamelen);
m_MinCtx->GetUtf8ObjectName(name_conv, file);
m_MinCtx->GetUtf8String(name_conv, file);
}
// read file body length
@ -335,7 +338,7 @@ namespace LibCmo {
// read file body
FILE* fp = m_MinCtx->OpenTempFile(file.c_str(), false);
if (fp != nullptr) {
Utils::CopyStream(parser->GetPtr(), fp, filebodylen);
StreamHelper::CopyStream(parser->GetPtr(), fp, filebodylen);
fclose(fp);
}

7
LibCmo/CKGlobals.cpp
View File

@ -4,12 +4,10 @@
#include <zconf.h>
#endif
#include "CKDefines.hpp"
#include "CKGlobals.hpp"
#include <zlib.h>
namespace LibCmo {
namespace LibCmo::CK2 {
void* CKUnPackData(CKINT DestSize, const void* SrcBuffer, CKINT SrcSize) {
char* DestBuffer = new(std::nothrow) char[DestSize];
@ -26,7 +24,7 @@ namespace LibCmo {
return DestBuffer;
}
CKDWORD LibCmo::CKComputeDataCRC(const void* data, size_t size, CKDWORD PreviousCRC) {
CKDWORD CKComputeDataCRC(const void* data, size_t size, CKDWORD PreviousCRC) {
return static_cast<CKDWORD>(adler32(
static_cast<uLong>(PreviousCRC),
reinterpret_cast<const Bytef*>(data),
@ -34,5 +32,4 @@ namespace LibCmo {
));
}
}

4
LibCmo/CKGlobals.hpp
View File

@ -1,6 +1,8 @@
#pragma once
namespace LibCmo {
#include "CKDefines.hpp"
namespace LibCmo::CK2 {
void* CKUnPackData(CKINT DestSize, const void* SrcBuffer, CKINT SrcSize);
CKDWORD CKComputeDataCRC(const void* data, size_t size, CKDWORD PreviousCRC = 0);

32
LibCmo/CKManagers.hpp Normal file
View File

@ -0,0 +1,32 @@
#pragma once
#include "CKDefines.hpp"
#include "CKEnums.hpp"
namespace LibCmo::CK2::CKManagerImplements {
class CKBaseManager {
public:
CKBaseManager();
CKBaseManager(const CKBaseManager&) = delete;
CKBaseManager& operator=(const CKBaseManager&) = delete;
virtual ~CKBaseManager();
virtual CKERROR LoadData(CKStateChunk* statechunk, CKFileData::ShallowDocument* doc);
virtual CKStateChunk* SaveData(CKFileData::ShallowDocument* doc);
private:
};
class CKAttributeManager {
public:
CKAttributeManager();
CKAttributeManager(const CKAttributeManager&) = delete;
CKAttributeManager& operator=(const CKAttributeManager&) = delete;
virtual ~CKAttributeManager();
private:
};
}

52
LibCmo/CKMinContext.cpp
View File

@ -1,7 +1,7 @@
#include "VTUtils.hpp"
#include "CKMinContext.hpp"
namespace LibCmo {
namespace LibCmo::CK2 {
#if defined(LIBCMO_OS_WIN32)
static wchar_t g_UniqueFolder[] = L"LibCmo";
@ -11,53 +11,69 @@ namespace LibCmo {
CKMinContext::CKMinContext() :
NameEncoding(), NameEncodingToken(Encoding::ENCODING_TOKEN_DEFAULT),
TempFolder()
m_NameEncoding(), m_NameEncodingToken(EncodingHelper::ENCODING_TOKEN_DEFAULT),
m_TempFolder(),
m_PrintCallback(nullptr)
{
// preset for temp folder
TempFolder = std::filesystem::temp_directory_path();
TempFolder /= g_UniqueFolder;
std::filesystem::create_directory(TempFolder);
m_TempFolder = std::filesystem::temp_directory_path();
m_TempFolder /= g_UniqueFolder;
std::filesystem::create_directory(m_TempFolder);
}
CKMinContext::~CKMinContext() {
}
void CKMinContext::Printf(CKSTRING fmt, ...) {
if (m_PrintCallback == nullptr) return;
va_list argptr;
va_start(argptr, fmt);
vfprintf(stdout, fmt, argptr);
std::string result;
int count = std::vsnprintf(nullptr, 0, fmt, argptr);
result.resize(count);
int write_result = std::vsnprintf(result.data(), count, fmt, argptr);
if (write_result < 0 || write_result > count) return;
va_end(argptr);
m_PrintCallback(result);
}
void CKMinContext::GetUtf8ObjectName(std::string& native_name, std::string& u8_name) {
Encoding::GetUtf8VirtoolsName(native_name, u8_name, this->NameEncodingToken);
void CKMinContext::SetPrintCallback(PrintCallback cb) {
m_PrintCallback = cb;
}
void CKMinContext::GetNativeObjectName(std::string& u8_name, std::string& native_name) {
Encoding::GetNativeVirtoolsName(u8_name, native_name, this->NameEncodingToken);
void CKMinContext::GetUtf8String(std::string& native_name, std::string& u8_name) {
EncodingHelper::GetUtf8VirtoolsName(native_name, u8_name, this->m_NameEncodingToken);
}
void CKMinContext::GetNativeString(std::string& u8_name, std::string& native_name) {
EncodingHelper::GetNativeVirtoolsName(u8_name, native_name, this->m_NameEncodingToken);
}
void CKMinContext::SetEncoding(CKSTRING encoding) {
this->NameEncoding = encoding;
this->m_NameEncoding = encoding;
this->RefetchEncodingToken();
}
void CKMinContext::SetTempPath(CKSTRING u8_temp) {
Encoding::SetStdPathFromU8Path(this->TempFolder, u8_temp);
EncodingHelper::SetStdPathFromU8Path(this->m_TempFolder, u8_temp);
}
FILE* CKMinContext::OpenTempFile(CKSTRING u8_filename, bool is_read) {
std::filesystem::path stdfilename;
Encoding::SetStdPathFromU8Path(stdfilename, u8_filename);
EncodingHelper::SetStdPathFromU8Path(stdfilename, u8_filename);
auto realfile = this->TempFolder / stdfilename;
return Encoding::OpenStdPathFile(realfile, is_read);
auto realfile = this->m_TempFolder / stdfilename;
return EncodingHelper::OpenStdPathFile(realfile, is_read);
}
void CKMinContext::RefetchEncodingToken(void) {
Encoding::DestroyEncodingToken(this->NameEncodingToken);
this->NameEncodingToken = Encoding::CreateEncodingToken(this->NameEncoding);
EncodingHelper::DestroyEncodingToken(this->m_NameEncodingToken);
this->m_NameEncodingToken = EncodingHelper::CreateEncodingToken(this->m_NameEncoding);
}
}

27
LibCmo/CKMinContext.hpp
View File

@ -1,12 +1,11 @@
#pragma once
#include "CKDefines.hpp"
#include "CKEnums.hpp"
#include "CKObjects.hpp"
#include "VTEncoding.hpp"
#include "VTObjects.hpp"
#include <filesystem>
namespace LibCmo {
namespace LibCmo::CK2 {
class CKMinContext {
public:
@ -15,13 +14,20 @@ namespace LibCmo {
CKMinContext& operator=(const CKMinContext&) = delete;
~CKMinContext();
using PrintCallback = void (*)(std::string&);
void Printf(CKSTRING fmt, ...);
void SetPrintCallback(PrintCallback cb);
ObjsImpl::CKObject* CreateObject(CK_ID id, CK_CLASSID cls, CKSTRING name);
void DestroyObject(ObjsImpl::CKObject* obj);
CKObjectImplements::CKObject* CreateCKObject(CK_ID id, CK_CLASSID cls, CKSTRING name);
CKObjectImplements::CKObject* GetCKObject(CK_ID id);
void DestroyCKObject(CKObjectImplements::CKObject* obj);
void GetUtf8ObjectName(std::string& native_name, std::string& u8_name);
void GetNativeObjectName(std::string& u8_name, std::string& native_name);
CKManagerImplements::CKBaseManager* CreateCKManager(CKGUID guid);
CKManagerImplements::CKBaseManager* GetCKManager(CKGUID guid);
void DestroyCKManager(CKManagerImplements::CKBaseManager* mgr);
void GetUtf8String(std::string& native_name, std::string& u8_name);
void GetNativeString(std::string& u8_name, std::string& native_name);
void SetEncoding(CKSTRING encoding);
void SetTempPath(CKSTRING u8_temp);
@ -31,9 +37,10 @@ namespace LibCmo {
private:
void RefetchEncodingToken(void);
std::string NameEncoding;
Encoding::ENCODING_TOKEN NameEncodingToken;
std::filesystem::path TempFolder;
std::string m_NameEncoding;
EncodingHelper::ENCODING_TOKEN m_NameEncodingToken;
std::filesystem::path m_TempFolder;
PrintCallback m_PrintCallback;
};
}

13
LibCmo/CKObjectImplements/CKObject.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "../CKObjects.hpp"
namespace LibCmo::CK2::CKObjectImplements {
CKObject::CKObject() {
}
CKObject::~CKObject() {
}
}

140
LibCmo/CKObjects.hpp Normal file
View File

@ -0,0 +1,140 @@
#pragma once
#include "CKDefines.hpp"
#include "CKEnums.hpp"
namespace LibCmo::CK2::CKObjectImplements {
class CKObject {
public:
CKObject();
CKObject(const CKObject&) = delete;
CKObject& operator=(const CKObject&) = delete;
virtual ~CKObject();
CK_ID GetID(void) { return this->m_ID; }
CKSTRING GetName(void) { return this->m_Name.c_str(); }
void SetName(CKSTRING u8_name) { this->m_Name = u8_name; }
CK_OBJECT_FLAGS GetObjectFlags(void) { return this->m_ObjectFlags; }
void SetObjectFlags(CK_OBJECT_FLAGS flags) { this->m_ObjectFlags = flags; }
virtual CK_CLASSID GetClassID(void) { return CK_CLASSID::CKCID_OBJECT; }
virtual CKERROR Load(CKStateChunk* chunk, 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 {
public:
CKSceneObject();
CKSceneObject(const CKSceneObject&) = delete;
CKSceneObject& operator=(const CKSceneObject&) = delete;
virtual ~CKSceneObject();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_SCENEOBJECT; }
protected:
XBitArray m_Scenes;
};
class CKBeObject : public CKSceneObject {
public:
CKBeObject();
CKBeObject(const CKBeObject&) = delete;
CKBeObject& operator=(const CKBeObject&) = delete;
virtual ~CKBeObject();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_BEOBJECT; }
protected:
};
class CKGroup : public CKBeObject {
public:
CKGroup();
CKGroup(const CKGroup&) = delete;
CKGroup& operator=(const CKGroup&) = delete;
virtual ~CKGroup();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_GROUP; }
protected:
};
class CKMesh : public CKBeObject {
public:
CKMesh();
CKMesh(const CKMesh&) = delete;
CKMesh& operator=(const CKMesh&) = delete;
virtual ~CKMesh();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_MESH; }
protected:
};
class CKTexture : public CKBeObject {
public:
CKTexture();
CKTexture(const CKTexture&) = delete;
CKTexture& operator=(const CKTexture&) = delete;
virtual ~CKTexture();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_TEXTURE; }
protected:
};
class CKMaterial : public CKBeObject {
public:
CKMaterial();
CKMaterial(const CKMaterial&) = delete;
CKMaterial& operator=(const CKMaterial&) = delete;
virtual ~CKMaterial();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_MATERIAL; }
protected:
};
class CKRenderObject : public CKBeObject {
public:
CKRenderObject();
CKRenderObject(const CKRenderObject&) = delete;
CKRenderObject& operator=(const CKRenderObject&) = delete;
~CKRenderObject();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_RENDEROBJECT; }
protected:
};
class CK3dEntity : public CKBeObject {
public:
CK3dEntity();
CK3dEntity(const CK3dEntity&) = delete;
CK3dEntity& operator=(const CK3dEntity&) = delete;
virtual ~CK3dEntity();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_3DENTITY; }
protected:
};
class CK3dObject :public CK3dEntity {
public:
CK3dObject();
CK3dObject(const CK3dObject&) = delete;
CK3dObject& operator=(const CK3dObject&) = delete;
~CK3dObject();
virtual CK_CLASSID GetClassID(void) override { return CK_CLASSID::CKCID_3DOBJECT; }
protected:
};
}

38
LibCmo/CKStateChunk.cpp
View File

@ -1,13 +1,7 @@
#include "VTUtils.hpp"
#if defined(LIBCMO_OS_WIN32)
#define ZLIB_WINAPI
#include <zconf.h>
#endif
#include <zlib.h>
#include "CKStateChunk.hpp"
namespace LibCmo {
namespace LibCmo::CK2 {
#pragma region Ctor Dtor
@ -29,7 +23,7 @@ namespace LibCmo {
if (rhs.m_pData != nullptr) {
this->m_pData = new(std::nothrow) CKDWORD[rhs.m_DataDwSize];
if (this->m_pData != nullptr) {
memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize);
std::memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize);
}
}
}
@ -50,7 +44,7 @@ namespace LibCmo {
if (rhs.m_pData != nullptr) {
this->m_pData = new(std::nothrow) CKDWORD[rhs.m_DataDwSize];
if (this->m_pData != nullptr) {
memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize);
std::memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize);
}
}
this->m_DataDwSize = rhs.m_DataDwSize;
@ -90,7 +84,7 @@ namespace LibCmo {
return sizeof(CKDWORD) * this->m_DataDwSize;
}
void LibCmo::CKStateChunk::_EnsureWriteSpace(CKDWORD size) {
void CKStateChunk::_EnsureWriteSpace(CKDWORD size) {
;
}
@ -129,15 +123,15 @@ namespace LibCmo {
this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize];
if (m_pData == nullptr) return false;
memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
bufpos += this->m_DataDwSize;
}
if (!this->m_ObjectList.empty()) {
memcpy(this->m_ObjectList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ObjectList.size());
std::memcpy(this->m_ObjectList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ObjectList.size());
bufpos += this->m_ObjectList.size();
}
if (!this->m_ChunkList.empty()) {
memcpy(this->m_ChunkList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ChunkList.size());
std::memcpy(this->m_ChunkList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ChunkList.size());
bufpos += this->m_ChunkList.size();
}
@ -156,19 +150,19 @@ namespace LibCmo {
this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize];
if (m_pData == nullptr) return false;
memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
bufpos += this->m_DataDwSize;
}
if (!this->m_ObjectList.empty()) {
memcpy(this->m_ObjectList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ObjectList.size());
std::memcpy(this->m_ObjectList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ObjectList.size());
bufpos += this->m_ObjectList.size();
}
if (!this->m_ChunkList.empty()) {
memcpy(this->m_ChunkList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ChunkList.size());
std::memcpy(this->m_ChunkList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ChunkList.size());
bufpos += this->m_ChunkList.size();
}
if (!this->m_ManagerList.empty()) {
memcpy(this->m_ManagerList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ManagerList.size());
std::memcpy(this->m_ManagerList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ManagerList.size());
bufpos += this->m_ManagerList.size();
}
@ -193,7 +187,7 @@ namespace LibCmo {
this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize];
if (m_pData == nullptr) return false;
memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
bufpos += this->m_DataDwSize;
}
if (EnumsHelper::FlagEnumHas(options, CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_FILE)) {
@ -203,19 +197,19 @@ namespace LibCmo {
if (EnumsHelper::FlagEnumHas(options, CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_IDS)) {
this->m_ObjectList.resize(dwbuf[bufpos]);
bufpos += 1u;
memcpy(this->m_ObjectList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ObjectList.size());
std::memcpy(this->m_ObjectList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ObjectList.size());
bufpos += this->m_ObjectList.size();
}
if (EnumsHelper::FlagEnumHas(options, CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_CHN)) {
this->m_ChunkList.resize(dwbuf[bufpos]);
bufpos += 1u;
memcpy(this->m_ChunkList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ChunkList.size());
std::memcpy(this->m_ChunkList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ChunkList.size());
bufpos += this->m_ChunkList.size();
}
if (EnumsHelper::FlagEnumHas(options, CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_MAN)) {
this->m_ManagerList.resize(dwbuf[bufpos]);
bufpos += 1u;
memcpy(this->m_ManagerList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ManagerList.size());
std::memcpy(this->m_ManagerList.data(), dwbuf + bufpos, sizeof(CKDWORD) * this->m_ManagerList.size());
bufpos += this->m_ManagerList.size();
}
@ -257,7 +251,7 @@ namespace LibCmo {
// this->m_pData = nullptr;
// this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize];
// if (this->m_pData != nullptr) {
// memcpy(this->m_pData, buffer, this->m_DataDwSize * sizeof(CKDWORD));
// std::memcpy(this->m_pData, buffer, this->m_DataDwSize * sizeof(CKDWORD));
// }
// }
// delete[] buffer;

2
LibCmo/CKStateChunk.hpp
View File

@ -3,7 +3,7 @@
#include "CKDefines.hpp"
#include "CKEnums.hpp"
namespace LibCmo {
namespace LibCmo::CK2 {
class CKStateChunk {
public:

10
LibCmo/LibCmo.vcxproj
View File

@ -103,6 +103,7 @@
<AdditionalIncludeDirectories>$(ZLIB_PATH);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp20</LanguageStandard>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -121,6 +122,7 @@
<AdditionalIncludeDirectories>$(ZLIB_PATH);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp20</LanguageStandard>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -139,6 +141,7 @@
<AdditionalIncludeDirectories>$(ZLIB_PATH);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp20</LanguageStandard>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -159,6 +162,7 @@
<AdditionalIncludeDirectories>$(ZLIB_PATH);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp20</LanguageStandard>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -175,7 +179,7 @@
<ClCompile Include="CKFileWriter.cpp" />
<ClCompile Include="CKGlobals.cpp" />
<ClCompile Include="CKMinContext.cpp" />
<ClCompile Include="ObjsImpl\CKObject.cpp" />
<ClCompile Include="CKObjectImplements\CKObject.cpp" />
<ClCompile Include="VTEncoding.cpp" />
<ClCompile Include="CKFileReader.cpp" />
<ClCompile Include="CKStateChunk.cpp" />
@ -187,11 +191,11 @@
<ClInclude Include="CKEnums.hpp" />
<ClInclude Include="CKFile.hpp" />
<ClInclude Include="CKGlobals.hpp" />
<ClInclude Include="CKManagers.hpp" />
<ClInclude Include="CKMinContext.hpp" />
<ClInclude Include="CKStateChunk.hpp" />
<ClInclude Include="VTEncoding.hpp" />
<ClInclude Include="VTManagers.hpp" />
<ClInclude Include="VTObjects.hpp" />
<ClInclude Include="CKObjects.hpp" />
<ClInclude Include="VTUtils.hpp" />
<ClInclude Include="VxMemoryMappedFile.hpp" />
</ItemGroup>

13
LibCmo/LibCmo.vcxproj.filters
View File

@ -13,9 +13,12 @@
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Sources\ObjsImpl">
<Filter Include="Sources\CKObjectImplements">
<UniqueIdentifier>{a8cd2188-b552-478c-9801-a6286b3d48a0}</UniqueIdentifier>
</Filter>
<Filter Include="Sources\CKManagerImplements">
<UniqueIdentifier>{784282d9-4adb-40ca-bbac-902c74e9a2e5}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="CKFileReader.cpp">
@ -33,8 +36,8 @@
<ClCompile Include="CKFileWriter.cpp">
<Filter>Sources</Filter>
</ClCompile>
<ClCompile Include="ObjsImpl\CKObject.cpp">
<Filter>Sources\ObjsImpl</Filter>
<ClCompile Include="CKObjectImplements\CKObject.cpp">
<Filter>Sources\CKObjectImplements</Filter>
</ClCompile>
<ClCompile Include="CKGlobals.cpp">
<Filter>Sources</Filter>
@ -56,7 +59,7 @@
<ClInclude Include="VTEncoding.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="VTObjects.hpp">
<ClInclude Include="CKObjects.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="CKDefines.hpp">
@ -80,7 +83,7 @@
<ClInclude Include="CKMinContext.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="VTManagers.hpp">
<ClInclude Include="CKManagers.hpp">
<Filter>Headers</Filter>
</ClInclude>
</ItemGroup>

15
LibCmo/ObjsImpl/CKObject.cpp
View File

@ -1,15 +0,0 @@
#include "../VTObjects.hpp"
namespace LibCmo {
namespace ObjsImpl {
CKObject::CKObject() {
}
CKObject::~CKObject() {
}
}
}

192
LibCmo/VTEncoding.cpp
View File

@ -1,78 +1,77 @@
#include "VTEncoding.hpp"
namespace LibCmo {
namespace Encoding {
namespace LibCmo::EncodingHelper {
#pragma region assist functions
#if defined(LIBCMO_OS_WIN32)
#define LIBCMO_STR_EQUAL(a, b) strcmp(reinterpret_cast<const char*>(a), reinterpret_cast<const char*>(b)) == 0
bool GetWindowsCodePage(const char* u8_encoding_spec, UINT* result) {
if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_ACP")) *result = CP_ACP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_MACCP")) *result = CP_MACCP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_OEMCP")) *result = CP_OEMCP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_THREAD_ACPP")) *result = CP_THREAD_ACP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_UTF8")) *result = CP_UTF8;
else {
char* pend = nullptr;
errno = 0;
uint64_t v = std::strtoull(u8_encoding_spec, &pend, 10);
bool GetWindowsCodePage(const char* u8_encoding_spec, UINT* result) {
if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_ACP")) *result = CP_ACP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_MACCP")) *result = CP_MACCP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_OEMCP")) *result = CP_OEMCP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_THREAD_ACPP")) *result = CP_THREAD_ACP;
else if (LIBCMO_STR_EQUAL(u8_encoding_spec, u8"CP_UTF8")) *result = CP_UTF8;
else {
char* pend = nullptr;
errno = 0;
uint64_t v = std::strtoull(u8_encoding_spec, &pend, 10);
if (pend == u8_encoding_spec || errno == ERANGE) return false;
*result = static_cast<UINT>(v);
}
return true;
if (pend == u8_encoding_spec || errno == ERANGE) return false;
*result = static_cast<UINT>(v);
}
return true;
}
#undef LIBCMO_STR_EQUAL
bool WcharToChar(const wchar_t* src, std::string& dest, UINT codepage) {
int count, write_result;
bool WcharToChar(const wchar_t* src, std::string& dest, UINT codepage) {
int count, write_result;
//converter to CHAR
count = WideCharToMultiByte(CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL);
if (count <= 0) return false;
//converter to CHAR
count = WideCharToMultiByte(CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL);
if (count <= 0) return false;
dest.resize(count);
write_result = WideCharToMultiByte(CP_UTF8, 0, src, -1, dest.data(), count, NULL, NULL);
if (write_result <= 0) return false;
dest.resize(count);
write_result = WideCharToMultiByte(CP_UTF8, 0, src, -1, dest.data(), count, NULL, NULL);
if (write_result <= 0) return false;
return true;
}
bool WcharToChar(std::wstring& src, std::string& dest, UINT codepage) {
return WcharToChar(src.c_str(), dest, codepage);
}
return true;
}
bool WcharToChar(std::wstring& src, std::string& dest, UINT codepage) {
return WcharToChar(src.c_str(), dest, codepage);
}
bool CharToWchar(const char* src, std::wstring& dest, UINT codepage) {
int wcount, write_result;
bool CharToWchar(const char* src, std::wstring& dest, UINT codepage) {
int wcount, write_result;
// convert to WCHAR
wcount = MultiByteToWideChar(codepage, 0, src, -1, NULL, 0);
if (wcount <= 0) return false;
// convert to WCHAR
wcount = MultiByteToWideChar(codepage, 0, src, -1, NULL, 0);
if (wcount <= 0) return false;
dest.resize(wcount);
write_result = MultiByteToWideChar(CP_UTF8, 0, src, -1, dest.data(), wcount);
if (write_result <= 0) return false;
dest.resize(wcount);
write_result = MultiByteToWideChar(CP_UTF8, 0, src, -1, dest.data(), wcount);
if (write_result <= 0) return false;
return true;
}
bool CharToWchar(std::string& src, std::wstring& dest, UINT codepage) {
return CharToWchar(src.c_str(), dest, codepage);
}
return true;
}
bool CharToWchar(std::string& src, std::wstring& dest, UINT codepage) {
return CharToWchar(src.c_str(), dest, codepage);
}
bool CharToChar(const char* src, std::string& dest, UINT src_codepage, UINT dest_codepage) {
std::wstring intermediary;
if (!CharToWchar(src, intermediary, src_codepage)) return false;
if (!WcharToChar(intermediary, dest, dest_codepage)) return false;
return true;
}
bool CharToChar(std::string& src, std::string& dest, UINT src_codepage, UINT dest_codepage) {
return CharToChar(src.c_str(), dest, src_codepage, dest_codepage);
}
bool CharToChar(const char* src, std::string& dest, UINT src_codepage, UINT dest_codepage) {
std::wstring intermediary;
if (!CharToWchar(src, intermediary, src_codepage)) return false;
if (!WcharToChar(intermediary, dest, dest_codepage)) return false;
return true;
}
bool CharToChar(std::string& src, std::string& dest, UINT src_codepage, UINT dest_codepage) {
return CharToChar(src.c_str(), dest, src_codepage, dest_codepage);
}
#else
//todo: linux implementation
//todo: linux implementation
#endif
@ -82,71 +81,70 @@ namespace LibCmo {
#if defined(LIBCMO_OS_WIN32)
const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT = nullptr;
const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT = nullptr;
ENCODING_TOKEN CreateEncodingToken(std::string& token_string) {
ENCODING_TOKEN token = new(std::nothrow) UINT();
if (token == nullptr) return ENCODING_TOKEN_DEFAULT;
ENCODING_TOKEN CreateEncodingToken(std::string& token_string) {
ENCODING_TOKEN token = new(std::nothrow) UINT();
if (token == nullptr) return ENCODING_TOKEN_DEFAULT;
if (!GetWindowsCodePage(token_string.c_str(), token)) {
*token = CP_ACP;
}
return token;
if (!GetWindowsCodePage(token_string.c_str(), token)) {
*token = CP_ACP;
}
void DestroyEncodingToken(ENCODING_TOKEN token) {
if (token != ENCODING_TOKEN_DEFAULT) {
delete token;
}
return token;
}
void DestroyEncodingToken(ENCODING_TOKEN token) {
if (token != ENCODING_TOKEN_DEFAULT) {
delete token;
}
}
void GetUtf8VirtoolsName(std::string& native_name, std::string& u8_name, ENCODING_TOKEN token) {
if (token == ENCODING_TOKEN_DEFAULT) {
u8_name = native_name.c_str();
return;
}
void GetUtf8VirtoolsName(std::string& native_name, std::string& u8_name, ENCODING_TOKEN token) {
if (token == ENCODING_TOKEN_DEFAULT) {
u8_name = native_name.c_str();
return;
}
// convert with fallback
if (!CharToChar(native_name, u8_name, *token, CP_UTF8)) {
u8_name = native_name.c_str();
}
}
// convert with fallback
if (!CharToChar(native_name, u8_name, *token, CP_UTF8)) {
u8_name = native_name.c_str();
}
void GetNativeVirtoolsName(std::string& u8_name, std::string& native_name, ENCODING_TOKEN token) {
if (token == ENCODING_TOKEN_DEFAULT) {
native_name = u8_name.c_str();
return;
}
void GetNativeVirtoolsName(std::string& u8_name, std::string& native_name, ENCODING_TOKEN token) {
if (token == ENCODING_TOKEN_DEFAULT) {
native_name = u8_name.c_str();
return;
}
// convert with fallback
if (!CharToChar(u8_name, native_name, CP_UTF8, *token)) {
native_name = u8_name.c_str();
}
// convert with fallback
if (!CharToChar(u8_name, native_name, CP_UTF8, *token)) {
native_name = u8_name.c_str();
}
}
void SetStdPathFromU8Path(std::filesystem::path& stdpath, const char* u8_path) {
std::wstring intermediary;
if (CharToWchar(u8_path, intermediary, CP_UTF8)) {
stdpath = intermediary.c_str();
} else {
// fallback
stdpath = u8_path;
}
void SetStdPathFromU8Path(std::filesystem::path& stdpath, const char* u8_path) {
std::wstring intermediary;
if (CharToWchar(u8_path, intermediary, CP_UTF8)) {
stdpath = intermediary.c_str();
} else {
// fallback
stdpath = u8_path;
}
}
FILE* OpenStdPathFile(std::filesystem::path& u8_filepath, bool is_read) {
return _wfopen(u8_filepath.wstring().c_str(), is_read ? L"rb" : L"wb");
}
FILE* OpenStdPathFile(std::filesystem::path& u8_filepath, bool is_read) {
return _wfopen(u8_filepath.wstring().c_str(), is_read ? L"rb" : L"wb");
}
#else
const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT = nullptr;
const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT = nullptr;
//todo: linux implementation
//todo: linux implementation
#endif
#pragma endregion
}
}

54
LibCmo/VTEncoding.hpp
View File

@ -11,23 +11,22 @@
#include <iconv.h>
#endif
namespace LibCmo {
namespace Encoding {
namespace LibCmo::EncodingHelper {
#pragma region assist functions
#if defined(LIBCMO_OS_WIN32)
bool GetWindowsCodePage(const char* u8_encoding_spec, UINT* result);
bool GetWindowsCodePage(const char* u8_encoding_spec, UINT* result);
bool WcharToChar(const wchar_t* src, std::string& dest, UINT codepage);
bool WcharToChar(std::wstring& src, std::string& dest, UINT codepage);
bool WcharToChar(const wchar_t* src, std::string& dest, UINT codepage);
bool WcharToChar(std::wstring& src, std::string& dest, UINT codepage);
bool CharToWchar(const char* src, std::wstring& dest, UINT codepage);
bool CharToWchar(std::string& src, std::wstring& dest, UINT codepage);
bool CharToWchar(const char* src, std::wstring& dest, UINT codepage);
bool CharToWchar(std::string& src, std::wstring& dest, UINT codepage);
bool CharToChar(const char* src, std::string& dest, UINT src_codepage, UINT dest_codepage);
bool CharToChar(std::string& src, std::string& dest, UINT src_codepage, UINT dest_codepage);
bool CharToChar(const char* src, std::string& dest, UINT src_codepage, UINT dest_codepage);
bool CharToChar(std::string& src, std::string& dest, UINT src_codepage, UINT dest_codepage);
#else
#error NO IMPLEMENTATION FOR LINUX ENCODING!
@ -39,35 +38,34 @@ namespace LibCmo {
#if defined(LIBCMO_OS_WIN32)
/// <summary>
/// Token is the ticket for using encoding functions.
/// It should be created by "GenerateEncodingToken" and free by "DestroyEncodingToken".
/// </summary>
using ENCODING_TOKEN = UINT*;
extern const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT;
/// <summary>
/// Token is the ticket for using encoding functions.
/// It should be created by "GenerateEncodingToken" and free by "DestroyEncodingToken".
/// </summary>
using ENCODING_TOKEN = UINT*;
extern const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT;
ENCODING_TOKEN CreateEncodingToken(std::string& token_string);
void DestroyEncodingToken(ENCODING_TOKEN token);
ENCODING_TOKEN CreateEncodingToken(std::string& token_string);
void DestroyEncodingToken(ENCODING_TOKEN token);
void GetUtf8VirtoolsName(std::string& native_name, std::string& u8_name, ENCODING_TOKEN token);
void GetNativeVirtoolsName(std::string& u8_name, std::string& native_name, ENCODING_TOKEN token);
void GetUtf8VirtoolsName(std::string& native_name, std::string& u8_name, ENCODING_TOKEN token);
void GetNativeVirtoolsName(std::string& u8_name, std::string& native_name, ENCODING_TOKEN token);
void SetStdPathFromU8Path(std::filesystem::path& stdpath, const char* u8_path);
FILE* OpenStdPathFile(std::filesystem::path& u8_filepath, bool is_read);
void SetStdPathFromU8Path(std::filesystem::path& stdpath, const char* u8_path);
FILE* OpenStdPathFile(std::filesystem::path& u8_filepath, bool is_read);
#else
/// <summary>
/// Token is the ticket for using encoding functions.
/// It should be created by "GenerateEncodingToken" and free by "DestroyEncodingToken".
/// </summary>
using ENCODING_TOKEN = char*;
extern const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT;
/// <summary>
/// Token is the ticket for using encoding functions.
/// It should be created by "GenerateEncodingToken" and free by "DestroyEncodingToken".
/// </summary>
using ENCODING_TOKEN = char*;
extern const ENCODING_TOKEN ENCODING_TOKEN_DEFAULT;
#error NO IMPLEMENTATION FOR LINUX ENCODING!
#endif
#pragma endregion
}
}

26
LibCmo/VTManagers.hpp
View File

@ -1,26 +0,0 @@
#pragma once
#include "CKDefines.hpp"
#include "CKEnums.hpp"
namespace LibCmo {
// forward decl to rm recursive reference
class CKMinContext;
class CKStateChunk;
namespace MgrsImpl {
class CKBaseManager {
public:
CKBaseManager();
CKBaseManager(const CKBaseManager&) = delete;
CKBaseManager& operator=(const CKBaseManager&) = delete;
virtual ~CKBaseManager();
private:
};
}
}

126
LibCmo/VTObjects.hpp
View File

@ -1,126 +0,0 @@
#pragma once
#include "CKDefines.hpp"
#include "CKEnums.hpp"
namespace LibCmo {
// forward decl to rm recursive reference
class CKMinContext;
class CKStateChunk;
namespace ObjsImpl {
class CKObject {
public:
CKObject();
CKObject(const CKObject&) = delete;
CKObject& operator=(const CKObject&) = delete;
virtual ~CKObject();
private:
};
class CKSceneObject : public CKObject {
public:
CKSceneObject();
CKSceneObject(const CKSceneObject&) = delete;
CKSceneObject& operator=(const CKSceneObject&) = delete;
virtual ~CKSceneObject();
private:
};
class CKBeObject : public CKSceneObject {
public:
CKBeObject();
CKBeObject(const CKBeObject&) = delete;
CKBeObject& operator=(const CKBeObject&) = delete;
virtual ~CKBeObject();
private:
};
class CKGroup : public CKBeObject {
public:
CKGroup();
CKGroup(const CKGroup&) = delete;
CKGroup& operator=(const CKGroup&) = delete;
virtual ~CKGroup();
private:
};
class CKMesh : public CKBeObject {
public:
CKMesh();
CKMesh(const CKMesh&) = delete;
CKMesh& operator=(const CKMesh&) = delete;
virtual ~CKMesh();
private:
};
class CKTexture : public CKBeObject {
public:
CKTexture();
CKTexture(const CKTexture&) = delete;
CKTexture& operator=(const CKTexture&) = delete;
virtual ~CKTexture();
private:
};
class CKMaterial : public CKBeObject {
public:
CKMaterial();
CKMaterial(const CKMaterial&) = delete;
CKMaterial& operator=(const CKMaterial&) = delete;
virtual ~CKMaterial();
private:
};
class CKRenderObject : public CKBeObject {
public:
CKRenderObject();
CKRenderObject(const CKRenderObject&) = delete;
CKRenderObject& operator=(const CKRenderObject&) = delete;
~CKRenderObject();
private:
};
class CK3dEntity : public CKBeObject {
public:
CK3dEntity();
CK3dEntity(const CK3dEntity&) = delete;
CK3dEntity& operator=(const CK3dEntity&) = delete;
virtual ~CK3dEntity();
private:
};
class CK3dObject :public CK3dEntity {
public:
CK3dObject();
CK3dObject(const CK3dObject&) = delete;
CK3dObject& operator=(const CK3dObject&) = delete;
~CK3dObject();
private:
};
}
}

3
LibCmo/VTUtils.cpp
View File

@ -1,8 +1,7 @@
#include "VTUtils.hpp"
namespace LibCmo {
namespace Utils {
namespace StreamHelper {
static constexpr const size_t CHUNK_SIZE = 10240;
void CopyStream(const void* src, FILE* dest, size_t len) {

24
LibCmo/VTUtils.hpp
View File

@ -42,9 +42,31 @@
#endif
#include <cstdio>
#include <type_traits>
#include <cinttypes>
#include <cstdint>
#include <cstdarg>
namespace LibCmo {
namespace Utils {
namespace EnumsHelper {
template<typename TEnum>
inline TEnum FlagEnumAdd(TEnum e, ...) {
TEnum result = e;
va_list argptr;
va_start(argptr, e);
result = static_cast<TEnum>(static_cast<std::underlying_type_t<TEnum>>(result) | static_cast<std::underlying_type_t<TEnum>>(va_arg(argptr, TEnum)));
va_end(argptr);
return result;
}
template<typename TEnum>
inline bool FlagEnumHas(TEnum e, TEnum probe) {
return static_cast<bool>(static_cast<std::underlying_type_t<TEnum>>(e) & static_cast<std::underlying_type_t<TEnum>>(probe));
}
}
namespace StreamHelper {
void CopyStream(const void* src, FILE* dest, size_t len);
void CopyStream(FILE* src, void* dest, size_t len);

4
LibCmo/VxMemoryMappedFile.cpp
View File

@ -1,7 +1,7 @@
#include "VxMemoryMappedFile.hpp"
#include "VTEncoding.hpp"
namespace LibCmo {
namespace LibCmo::VxMath {
VxMemoryMappedFile::VxMemoryMappedFile(const char* u8_filepath) :
// init members
@ -16,7 +16,7 @@ namespace LibCmo {
// save file path
#if defined(LIBCMO_OS_WIN32)
Encoding::SetStdPathFromU8Path(m_szFilePath, u8_filepath);
EncodingHelper::SetStdPathFromU8Path(m_szFilePath, u8_filepath);
#else
this->m_szFilePath = u8_filepath;
#endif

2
LibCmo/VxMemoryMappedFile.hpp
View File

@ -10,7 +10,7 @@
#include <string>
#include <filesystem>
namespace LibCmo {
namespace LibCmo::VxMath {
class VxMemoryMappedFile {
private: