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

fix: fix build issue in Unvirt and LibCmo

Browse Source 
- fix build issue in Unvirt and LibCmo
- due to we use UTF8 string. the accessible value generator in EnumsMigration need to be changed at the same time.
- remove string helper in Unvirt because we no longer need it.
This commit is contained in:
yyc12345 2024-08-23 17:38:45 +08:00
parent 0447381896
commit d74b4645f0
13 changed files with 823 additions and 766 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CodeGen/EnumsMigration/CppWriter.java
View File

@ -111,8 +111,8 @@ public class CppWriter {
IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp); IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
// write type defination (just to let user know what the type is) // write type defination (just to let user know what the type is)
indent.puts("// struct GeneralReflection { const char* mName; };"); indent.puts("// struct GeneralReflection { const char8_t* mName; };");
indent.puts("// template<typename _Ty>"); indent.puts("// template<typename _Ty, std::enable_if_t<std::is_enum_v<_Ty>, int> = 0>");
indent.puts("// using GeneralReflectionArray = std::vector<std::pair<_Ty, GeneralReflection>>;"); indent.puts("// using GeneralReflectionArray = std::vector<std::pair<_Ty, GeneralReflection>>;");
indent.puts(""); indent.puts("");
@ -138,7 +138,7 @@ public class CppWriter {
// write enum desc entries // write enum desc entries
for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) { for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
indent.printf("{ LibCmo::%s::%s::%s, {\"%s\"} },", CommonHelper.getCKPartsNamespace(parts), indent.printf("{ LibCmo::%s::%s::%s, { u8\"%s\" } },", CommonHelper.getCKPartsNamespace(parts),
enum_t.mEnumName, enumEntry_t.mEntryName, enumEntry_t.mEntryName); enum_t.mEnumName, enumEntry_t.mEntryName, enumEntry_t.mEntryName);
} }
@ -209,7 +209,7 @@ public class CppWriter {
IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp); IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
// write type defination (just to let user know what the type is) // write type defination (just to let user know what the type is)
indent.puts("// struct CkErrorReflection { const char* mName; const char* mDescription; };"); indent.puts("// struct CkErrorReflection { const char8_t* mName; const char8_t* mDescription; };");
indent.puts("// using CkErrorReflectionArray = std::vector<std::pair<LibCmo::CK2::CKERROR, CkErrorReflection>>;"); indent.puts("// using CkErrorReflectionArray = std::vector<std::pair<LibCmo::CK2::CKERROR, CkErrorReflection>>;");
indent.puts(""); indent.puts("");
@ -224,7 +224,7 @@ public class CppWriter {
if (comment == null) if (comment == null)
comment = ""; comment = "";
indent.printf("{ LibCmo::CK2::CKERROR::%s, { \"%s\", \"%s\" } },", entry.mEntryName, entry.mEntryName, indent.printf("{ LibCmo::CK2::CKERROR::%s, { u8\"%s\", u8\"%s\" } },", entry.mEntryName, entry.mEntryName,
comment); comment);
} }
indent.dec(); indent.dec();
@ -249,7 +249,7 @@ public class CppWriter {
IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp); IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
// write type defination (just to let user know what the type is) // write type defination (just to let user know what the type is)
indent.puts("// struct CkClassidReflection { std::vector<const char*> mHierarchy; };"); indent.puts("// struct CkClassidReflection { std::vector<const char8_t*> mHierarchy; };");
indent.puts("// using CkClassidReflectionArray = std::vector<std::pair<LibCmo::CK2::CK_CLASSID, CkClassidReflection>>;"); indent.puts("// using CkClassidReflectionArray = std::vector<std::pair<LibCmo::CK2::CK_CLASSID, CkClassidReflection>>;");
indent.puts(""); indent.puts("");
@ -262,8 +262,8 @@ public class CppWriter {
EnumsHelper.EnumEntryWithHierarchy_t specialized = (EnumsHelper.EnumEntryWithHierarchy_t) entry; EnumsHelper.EnumEntryWithHierarchy_t specialized = (EnumsHelper.EnumEntryWithHierarchy_t) entry;
String hierarchy = specialized.mHierarchy.stream().map(value -> value.mEntryName) String hierarchy = specialized.mHierarchy.stream().map(value -> value.mEntryName)
.collect(Collectors.joining("\", \"")); .collect(Collectors.joining("\", u8\""));
indent.printf("{ LibCmo::CK2::CK_CLASSID::%s, { { \"%s\" } } },", entry.mEntryName, hierarchy); indent.printf("{ LibCmo::CK2::CK_CLASSID::%s, { { u8\"%s\" } } },", entry.mEntryName, hierarchy);
} }
indent.dec(); indent.dec();
indent.puts("};"); indent.puts("};");

2
LibCmo/CK2/CKContext.hpp
View File

@ -109,6 +109,7 @@ namespace LibCmo::CK2 {
* The encoding of ordinary is specified by encoding sequence. * The encoding of ordinary is specified by encoding sequence.
* If we fail to do convertion, the result will leave to blank and output a message to CKContext. * If we fail to do convertion, the result will leave to blank and output a message to CKContext.
* However, if you use this function with blank encoding sequence, it will raise exception. * However, if you use this function with blank encoding sequence, it will raise exception.
* So becore using this function, please make sure that you have checked by calling IsValidEncoding().
*/ */
void GetUTF8String(const std::string& native_name, XContainer::XString& u8_name); void GetUTF8String(const std::string& native_name, XContainer::XString& u8_name);
/** /**
@ -120,6 +121,7 @@ namespace LibCmo::CK2 {
* The encoding of ordinary is specified by encoding sequence. * The encoding of ordinary is specified by encoding sequence.
* If we fail to do convertion, the result will leave to blank and output a message to CKContext. * If we fail to do convertion, the result will leave to blank and output a message to CKContext.
* However, if you use this function with blank encoding sequence, it will raise exception. * However, if you use this function with blank encoding sequence, it will raise exception.
* So becore using this function, please make sure that you have checked by calling IsValidEncoding().
*/ */
void GetOrdinaryString(const XContainer::XString& u8_name, std::string& native_name); void GetOrdinaryString(const XContainer::XString& u8_name, std::string& native_name);
/** /**

12
LibCmo/CK2/CKFileReader.cpp
View File

@ -18,6 +18,8 @@ namespace LibCmo::CK2 {
CKERROR CKFileReader::ShallowLoad(CKSTRING u8_filename) { CKERROR CKFileReader::ShallowLoad(CKSTRING u8_filename) {
// check document status // check document status
if (this->m_Done) return CKERROR::CKERR_CANCELLED; if (this->m_Done) return CKERROR::CKERR_CANCELLED;
// check CKContext encoding sequence
if (!this->m_Ctx->IsValidEncoding()) return CKERROR::CKERR_CANCELLED;
// check file and open memory // check file and open memory
if (u8_filename == nullptr) return CKERROR::CKERR_INVALIDPARAMETER; if (u8_filename == nullptr) return CKERROR::CKERR_INVALIDPARAMETER;
@ -35,6 +37,8 @@ namespace LibCmo::CK2 {
if (err != CKERROR::CKERR_OK) return err; if (err != CKERROR::CKERR_OK) return err;
// other data will be free automatically // other data will be free automatically
// set done flag and return
this->m_Done = true;
return CKERROR::CKERR_OK; return CKERROR::CKERR_OK;
} }
@ -335,6 +339,8 @@ namespace LibCmo::CK2 {
CKERROR CKFileReader::DeepLoad(CKSTRING u8_filename) { CKERROR CKFileReader::DeepLoad(CKSTRING u8_filename) {
// check document status // check document status
if (this->m_Done) return CKERROR::CKERR_CANCELLED; if (this->m_Done) return CKERROR::CKERR_CANCELLED;
// check CKContext encoding sequence
if (!this->m_Ctx->IsValidEncoding()) return CKERROR::CKERR_CANCELLED;
// ========== prepare work ========== // ========== prepare work ==========
CKERROR err = CKERROR::CKERR_OK; CKERROR err = CKERROR::CKERR_OK;
@ -342,6 +348,8 @@ namespace LibCmo::CK2 {
// get shallow document first // get shallow document first
err = this->ShallowLoad(u8_filename); err = this->ShallowLoad(u8_filename);
if (err != CKERROR::CKERR_OK) return err; if (err != CKERROR::CKERR_OK) return err;
// reset done flag because we need further processing
this->m_Done = false;
// ========== create object first ========== // ========== create object first ==========
for (auto& obj : this->m_FileObjects) { for (auto& obj : this->m_FileObjects) {
@ -387,6 +395,10 @@ namespace LibCmo::CK2 {
} }
// ========== finalize work ========== // ========== finalize work ==========
// set done flag and return
this->m_Done = true;
return CKERROR::CKERR_OK; return CKERROR::CKERR_OK;
} }

4
LibCmo/CK2/CKFileWriter.cpp
View File

@ -12,6 +12,8 @@ namespace LibCmo::CK2 {
CKERROR CKFileWriter::Save(CKSTRING u8_filename) { CKERROR CKFileWriter::Save(CKSTRING u8_filename) {
// check document status // check document status
if (this->m_Done) return CKERROR::CKERR_CANCELLED; if (this->m_Done) return CKERROR::CKERR_CANCELLED;
// check CKContext encoding sequence
if (!this->m_Ctx->IsValidEncoding()) return CKERROR::CKERR_CANCELLED;
// encoding conv helper // encoding conv helper
std::string name_conv; std::string name_conv;
@ -347,6 +349,8 @@ namespace LibCmo::CK2 {
// close file // close file
std::fclose(fs); std::fclose(fs);
// set done flag and return
this->m_Done = true;
return CKERROR::CKERR_OK; return CKERROR::CKERR_OK;
} }

7
LibCmo/CK2/CKTypes.hpp
View File

@ -89,6 +89,11 @@ namespace LibCmo {
#define PRI_CKSTRING "s" #define PRI_CKSTRING "s"
#define PRI_CKCHAR "c" #define PRI_CKCHAR "c"
#define CKBYTE_C(v) UINT8_C(v)
#define CKWORD_C(v) UINT16_C(v)
#define CKDWORD_C(v) UINT32_C(v)
#define CKQWORD_C(v) UINT64_C(v)
#define PRIuCKBYTE PRIu8 #define PRIuCKBYTE PRIu8
#define PRIuCKWORD PRIu16 #define PRIuCKWORD PRIu16
#define PRIuCKDWORD PRIu32 #define PRIuCKDWORD PRIu32
@ -104,6 +109,8 @@ namespace LibCmo {
#define PRIXCKDWORD PRIX32 #define PRIXCKDWORD PRIX32
#define PRIXCKQWORD PRIX64 #define PRIXCKQWORD PRIX64
#define CKINT_C(v) INT32_C(v)
#define PRIiCKINT PRIi32 #define PRIiCKINT PRIi32
#define PRIfCKFLOAT "f" #define PRIfCKFLOAT "f"

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

@ -15,6 +15,7 @@ namespace LibCmo::CK2::ObjImpls {
* All pointers should translate to DWORD(32 bit) for platform independent. * All pointers should translate to DWORD(32 bit) for platform independent.
* Otherwise this struct may be corrupted in x64 platform because pointer is QWORD in x64. * Otherwise this struct may be corrupted in x64 platform because pointer is QWORD in x64.
*/ */
#pragma pack(4)
struct FakeBitmapProperties { struct FakeBitmapProperties {
CKINT m_Size; CKINT m_Size;
struct { struct {
@ -23,7 +24,7 @@ namespace LibCmo::CK2::ObjImpls {
}m_ReaderGuid; }m_ReaderGuid;
struct { struct {
// fake CKFileExtension // fake CKFileExtension
CKCHAR m_Data[4]; char m_Data[4];
}m_Ext; }m_Ext;
struct { struct {
// fake VxImageDescEx // fake VxImageDescEx
@ -60,6 +61,7 @@ namespace LibCmo::CK2::ObjImpls {
}m_Format; }m_Format;
/*void**/CKPTR m_Data; /*void**/CKPTR m_Data;
}; };
#pragma pack()
CKTexture::CKTexture(CKContext* ctx, CK_ID ckid, CKSTRING name) : CKTexture::CKTexture(CKContext* ctx, CK_ID ckid, CKSTRING name) :
CKBeObject(ctx, ckid, name), CKBeObject(ctx, ckid, name),
@ -184,10 +186,12 @@ namespace LibCmo::CK2::ObjImpls {
// setup ext and guid // setup ext and guid
props.m_ReaderGuid.d1 = realprops.m_ReaderGuid.d1; props.m_ReaderGuid.d1 = realprops.m_ReaderGuid.d1;
props.m_ReaderGuid.d2 = realprops.m_ReaderGuid.d2; props.m_ReaderGuid.d2 = realprops.m_ReaderGuid.d2;
std::string ext;
m_Context->GetOrdinaryString(realprops.m_Ext.GetExt(), ext);
std::memcpy( std::memcpy(
props.m_Ext.m_Data, props.m_Ext.m_Data,
realprops.m_Ext.GetExt(), ext.c_str(),
std::min(CKSizeof(props.m_Ext.m_Data), realprops.m_Ext.GetSize()) std::min(CKSizeof(props.m_Ext.m_Data) - CKDWORD_C(1), static_cast<CKDWORD>(ext.size()))
); );
// write fake one // write fake one
@ -308,9 +312,14 @@ namespace LibCmo::CK2::ObjImpls {
if (buf != nullptr) { if (buf != nullptr) {
FakeBitmapProperties* props = static_cast<FakeBitmapProperties*>(buf.get()); FakeBitmapProperties* props = static_cast<FakeBitmapProperties*>(buf.get());
// get utf8 extension
XContainer::XString ext;
m_Context->GetUTF8String(props->m_Ext.m_Data, ext);
// get my bitmap prop
CKBitmapProperties myprops( CKBitmapProperties myprops(
CKGUID(props->m_ReaderGuid.d1, props->m_ReaderGuid.d2), CKGUID(props->m_ReaderGuid.d1, props->m_ReaderGuid.d2),
props->m_Ext.m_Data ext.c_str()
); );
m_ImageHost.SetSaveFormat(myprops); m_ImageHost.SetSaveFormat(myprops);
} }

845
Unvirt/AccessibleValue.cpp
View File

@ -4,181 +4,159 @@
namespace Unvirt::AccessibleValue { namespace Unvirt::AccessibleValue {
#pragma region File Formatter #pragma region Size Formatter
std::string GetReadableFileSize(uint64_t size) { std::u8string GetReadableFileSize(uint64_t _size) {
std::string strl; static constexpr double base = 1024.0;
static double denominator = (double)0b1111111111; static const std::vector<const char8_t*> units {
uint64_t probe = size; u8"B", u8"KiB", u8"MiB", u8"GiB", u8"TiB", u8"PiB", u8"EiB"
};
// check bytes double size = static_cast<double>(_size);
if ((probe >> 10) == UINT64_C(0)) { size_t unit_index = 0u;
StringHelper::StdstringPrintf(strl, "%" PRIu64 "Bytes", probe);
return strl; while (size >= base && (unit_index + 1u) < units.size()) {
size /= base;
++unit_index;
} }
probe >>= 10;
// check kb
if ((probe >> 10) == UINT64_C(0)) {
StringHelper::StdstringPrintf(strl, "%.2lfKiB", size / static_cast<double>(UINT64_C(1) << 10));
return strl;
}
probe >>= 10;
// check mb
if ((probe >> 10) == UINT64_C(0)) {
StringHelper::StdstringPrintf(strl, "%.2lfMiB", size / static_cast<double>(UINT64_C(1) << 20));
return strl;
}
probe >>= 10;
// otherwise gb
StringHelper::StdstringPrintf(strl, "%.2lfGiB", size / static_cast<double>(UINT64_C(1) << 30));
return strl;
return YYCC::StringHelper::Printf(u8"%.2lf%s", size, units[unit_index]);
} }
#pragma endregion #pragma endregion
#pragma region CKERROR CK_CLASSID Data #pragma region CKERROR CK_CLASSID Data
struct CkClassidReflection { std::vector<const char*> mHierarchy; }; struct CkClassidReflection { std::vector<const char8_t*> mHierarchy; };
using CkClassidReflectionArray = std::vector<std::pair<LibCmo::CK2::CK_CLASSID, CkClassidReflection>>; using CkClassidReflectionArray = std::vector<std::pair<LibCmo::CK2::CK_CLASSID, CkClassidReflection>>;
struct CkErrorReflection { const char* mName; const char* mDescription; }; struct CkErrorReflection { const char8_t* mName; const char8_t* mDescription; };
using CkErrorReflectionArray = std::vector<std::pair<LibCmo::CK2::CKERROR, CkErrorReflection>>; using CkErrorReflectionArray = std::vector<std::pair<LibCmo::CK2::CKERROR, CkErrorReflection>>;
namespace EnumDesc { namespace EnumDesc {
const GeneralReflectionArray<LibCmo::CK2::CK_FILE_WRITEMODE> CK_FILE_WRITEMODE {
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_UNCOMPRESSED, {"CKFILE_UNCOMPRESSED"} },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_CHUNKCOMPRESSED_OLD, {"CKFILE_CHUNKCOMPRESSED_OLD"} },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_EXTERNALTEXTURES_OLD, {"CKFILE_EXTERNALTEXTURES_OLD"} },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_FORVIEWER, {"CKFILE_FORVIEWER"} },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_WHOLECOMPRESSED, {"CKFILE_WHOLECOMPRESSED"} },
};
const CkClassidReflectionArray CK_CLASSID { const CkClassidReflectionArray CK_CLASSID {
{ LibCmo::CK2::CK_CLASSID::CKCID_OBJECT, { { "CKCID_OBJECT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_OBJECT, { { u8"CKCID_OBJECT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERIN, { { "CKCID_OBJECT", "CKCID_PARAMETERIN" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERIN, { { u8"CKCID_OBJECT", u8"CKCID_PARAMETERIN" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROPERATION, { { "CKCID_OBJECT", "CKCID_PARAMETEROPERATION" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROPERATION, { { u8"CKCID_OBJECT", u8"CKCID_PARAMETEROPERATION" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_STATE, { { "CKCID_OBJECT", "CKCID_STATE" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_STATE, { { u8"CKCID_OBJECT", u8"CKCID_STATE" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORLINK, { { "CKCID_OBJECT", "CKCID_BEHAVIORLINK" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORLINK, { { u8"CKCID_OBJECT", u8"CKCID_BEHAVIORLINK" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIOR, { { "CKCID_OBJECT", "CKCID_BEHAVIOR" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIOR, { { u8"CKCID_OBJECT", u8"CKCID_BEHAVIOR" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORIO, { { "CKCID_OBJECT", "CKCID_BEHAVIORIO" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORIO, { { u8"CKCID_OBJECT", u8"CKCID_BEHAVIORIO" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_RENDERCONTEXT, { { "CKCID_OBJECT", "CKCID_RENDERCONTEXT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_RENDERCONTEXT, { { u8"CKCID_OBJECT", u8"CKCID_RENDERCONTEXT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_KINEMATICCHAIN, { { "CKCID_OBJECT", "CKCID_KINEMATICCHAIN" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_KINEMATICCHAIN, { { u8"CKCID_OBJECT", u8"CKCID_KINEMATICCHAIN" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_OBJECTANIMATION, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_OBJECTANIMATION" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTANIMATION, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_OBJECTANIMATION" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_ANIMATION, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_ANIMATION" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_ANIMATION, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_ANIMATION" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_KEYEDANIMATION, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_ANIMATION", "CKCID_KEYEDANIMATION" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_KEYEDANIMATION, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_ANIMATION", u8"CKCID_KEYEDANIMATION" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_BEOBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_BEOBJECT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_DATAARRAY, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_DATAARRAY" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_DATAARRAY, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_DATAARRAY" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SCENE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SCENE" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SCENE, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_SCENE" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_LEVEL, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_LEVEL" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_LEVEL, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_LEVEL" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PLACE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_PLACE" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PLACE, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_PLACE" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_GROUP, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_GROUP" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_GROUP, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_GROUP" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SOUND, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SOUND, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_SOUND" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_WAVESOUND, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND", "CKCID_WAVESOUND" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_WAVESOUND, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_SOUND", u8"CKCID_WAVESOUND" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_MIDISOUND, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND", "CKCID_MIDISOUND" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_MIDISOUND, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_SOUND", u8"CKCID_MIDISOUND" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_MATERIAL, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MATERIAL" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_MATERIAL, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_MATERIAL" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_TEXTURE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_TEXTURE" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_TEXTURE, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_TEXTURE" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_MESH, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MESH" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_MESH, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_MESH" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PATCHMESH, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MESH", "CKCID_PATCHMESH" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PATCHMESH, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_MESH", u8"CKCID_PATCHMESH" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_RENDEROBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_RENDEROBJECT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_RENDEROBJECT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_2DENTITY, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "CKCID_2DENTITY" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_2DENTITY, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_RENDEROBJECT", u8"CKCID_2DENTITY" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SPRITE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "CKCID_2DENTITY", "CKCID_SPRITE" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SPRITE, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_RENDEROBJECT", u8"CKCID_2DENTITY", u8"CKCID_SPRITE" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SPRITETEXT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "CKCID_2DENTITY", "CKCID_SPRITETEXT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SPRITETEXT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_RENDEROBJECT", u8"CKCID_2DENTITY", u8"CKCID_SPRITETEXT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_3DENTITY, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_3DENTITY, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_GRID, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_GRID" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_GRID, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_GRID" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_CURVEPOINT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CURVEPOINT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_CURVEPOINT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_CURVEPOINT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SPRITE3D, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_SPRITE3D" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SPRITE3D, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_SPRITE3D" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_CURVE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CURVE" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_CURVE, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_CURVE" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_CAMERA, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CAMERA" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_CAMERA, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_CAMERA" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_TARGETCAMERA, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CAMERA", "CKCID_TARGETCAMERA" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_TARGETCAMERA, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_CAMERA", u8"CKCID_TARGETCAMERA" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_LIGHT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_LIGHT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_LIGHT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_LIGHT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_TARGETLIGHT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_LIGHT", "CKCID_TARGETLIGHT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_TARGETLIGHT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_LIGHT", u8"CKCID_TARGETLIGHT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_CHARACTER, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CHARACTER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_CHARACTER, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_CHARACTER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_3DOBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_3DOBJECT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_3DOBJECT, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_3DOBJECT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_BODYPART, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_3DOBJECT", "CKCID_BODYPART" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_BODYPART, { { u8"CKCID_OBJECT", u8"CKCID_SCENEOBJECT", u8"CKCID_BEOBJECT", u8"CKCID_3DENTITY", u8"CKCID_3DOBJECT", u8"CKCID_BODYPART" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PARAMETER, { { "CKCID_OBJECT", "CKCID_PARAMETER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETER, { { u8"CKCID_OBJECT", u8"CKCID_PARAMETER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERLOCAL, { { "CKCID_OBJECT", "CKCID_PARAMETER", "CKCID_PARAMETERLOCAL" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERLOCAL, { { u8"CKCID_OBJECT", u8"CKCID_PARAMETER", u8"CKCID_PARAMETERLOCAL" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROUT, { { "CKCID_OBJECT", "CKCID_PARAMETER", "CKCID_PARAMETEROUT" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROUT, { { u8"CKCID_OBJECT", u8"CKCID_PARAMETER", u8"CKCID_PARAMETEROUT" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_INTERFACEOBJECTMANAGER, { { "CKCID_OBJECT", "CKCID_INTERFACEOBJECTMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_INTERFACEOBJECTMANAGER, { { u8"CKCID_OBJECT", u8"CKCID_INTERFACEOBJECTMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_CRITICALSECTION, { { "CKCID_OBJECT", "CKCID_CRITICALSECTION" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_CRITICALSECTION, { { u8"CKCID_OBJECT", u8"CKCID_CRITICALSECTION" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_LAYER, { { "CKCID_OBJECT", "CKCID_LAYER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_LAYER, { { u8"CKCID_OBJECT", u8"CKCID_LAYER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PROGRESSIVEMESH, { { "CKCID_OBJECT", "CKCID_PROGRESSIVEMESH" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PROGRESSIVEMESH, { { u8"CKCID_OBJECT", u8"CKCID_PROGRESSIVEMESH" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SYNCHRO, { { "CKCID_OBJECT", "CKCID_SYNCHRO" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SYNCHRO, { { u8"CKCID_OBJECT", u8"CKCID_SYNCHRO" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_OBJECTARRAY, { { "CKCID_OBJECTARRAY" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTARRAY, { { u8"CKCID_OBJECTARRAY" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECTDESC, { { "CKCID_SCENEOBJECTDESC" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECTDESC, { { u8"CKCID_SCENEOBJECTDESC" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_ATTRIBUTEMANAGER, { { "CKCID_ATTRIBUTEMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_ATTRIBUTEMANAGER, { { u8"CKCID_ATTRIBUTEMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_MESSAGEMANAGER, { { "CKCID_MESSAGEMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_MESSAGEMANAGER, { { u8"CKCID_MESSAGEMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_COLLISIONMANAGER, { { "CKCID_COLLISIONMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_COLLISIONMANAGER, { { u8"CKCID_COLLISIONMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_OBJECTMANAGER, { { "CKCID_OBJECTMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTMANAGER, { { u8"CKCID_OBJECTMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_FLOORMANAGER, { { "CKCID_FLOORMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_FLOORMANAGER, { { u8"CKCID_FLOORMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_RENDERMANAGER, { { "CKCID_RENDERMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_RENDERMANAGER, { { u8"CKCID_RENDERMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORMANAGER, { { "CKCID_BEHAVIORMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORMANAGER, { { u8"CKCID_BEHAVIORMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_INPUTMANAGER, { { "CKCID_INPUTMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_INPUTMANAGER, { { u8"CKCID_INPUTMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERMANAGER, { { "CKCID_PARAMETERMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERMANAGER, { { u8"CKCID_PARAMETERMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_GRIDMANAGER, { { "CKCID_GRIDMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_GRIDMANAGER, { { u8"CKCID_GRIDMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_SOUNDMANAGER, { { "CKCID_SOUNDMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_SOUNDMANAGER, { { u8"CKCID_SOUNDMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_TIMEMANAGER, { { "CKCID_TIMEMANAGER" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_TIMEMANAGER, { { u8"CKCID_TIMEMANAGER" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_CUIKBEHDATA, { { "CKCID_CUIKBEHDATA" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_CUIKBEHDATA, { { u8"CKCID_CUIKBEHDATA" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_MAXCLASSID, { { "CKCID_MAXCLASSID" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_MAXCLASSID, { { u8"CKCID_MAXCLASSID" } } },
{ LibCmo::CK2::CK_CLASSID::CKCID_MAXMAXCLASSID, { { "CKCID_MAXMAXCLASSID" } } }, { LibCmo::CK2::CK_CLASSID::CKCID_MAXMAXCLASSID, { { u8"CKCID_MAXMAXCLASSID" } } },
}; };
const CkErrorReflectionArray CKERROR { const CkErrorReflectionArray CKERROR {
{ LibCmo::CK2::CKERROR::CKERR_OK, { "CKERR_OK", "Operation successful " } }, { LibCmo::CK2::CKERROR::CKERR_OK, { u8"CKERR_OK", u8"Operation successful " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDPARAMETER, { "CKERR_INVALIDPARAMETER", "One of the parameter passed to the function was invalid " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDPARAMETER, { u8"CKERR_INVALIDPARAMETER", u8"One of the parameter passed to the function was invalid " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDPARAMETERTYPE, { "CKERR_INVALIDPARAMETERTYPE", "One of the parameter passed to the function was invalid " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDPARAMETERTYPE, { u8"CKERR_INVALIDPARAMETERTYPE", u8"One of the parameter passed to the function was invalid " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDSIZE, { "CKERR_INVALIDSIZE", "The parameter size was invalid " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDSIZE, { u8"CKERR_INVALIDSIZE", u8"The parameter size was invalid " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDOPERATION, { "CKERR_INVALIDOPERATION", "The operation type didn't exist " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDOPERATION, { u8"CKERR_INVALIDOPERATION", u8"The operation type didn't exist " } },
{ LibCmo::CK2::CKERROR::CKERR_OPERATIONNOTIMPLEMENTED, { "CKERR_OPERATIONNOTIMPLEMENTED", "The function used to execute the operation is not yet implemented " } }, { LibCmo::CK2::CKERROR::CKERR_OPERATIONNOTIMPLEMENTED, { u8"CKERR_OPERATIONNOTIMPLEMENTED", u8"The function used to execute the operation is not yet implemented " } },
{ LibCmo::CK2::CKERROR::CKERR_OUTOFMEMORY, { "CKERR_OUTOFMEMORY", "There was not enough memory to perform the action " } }, { LibCmo::CK2::CKERROR::CKERR_OUTOFMEMORY, { u8"CKERR_OUTOFMEMORY", u8"There was not enough memory to perform the action " } },
{ LibCmo::CK2::CKERROR::CKERR_NOTIMPLEMENTED, { "CKERR_NOTIMPLEMENTED", "The function is not yet implemented " } }, { LibCmo::CK2::CKERROR::CKERR_NOTIMPLEMENTED, { u8"CKERR_NOTIMPLEMENTED", u8"The function is not yet implemented " } },
{ LibCmo::CK2::CKERROR::CKERR_NOTFOUND, { "CKERR_NOTFOUND", "There was an attempt to remove something not present " } }, { LibCmo::CK2::CKERROR::CKERR_NOTFOUND, { u8"CKERR_NOTFOUND", u8"There was an attempt to remove something not present " } },
{ LibCmo::CK2::CKERROR::CKERR_NOLEVEL, { "CKERR_NOLEVEL", "There is no level currently created " } }, { LibCmo::CK2::CKERROR::CKERR_NOLEVEL, { u8"CKERR_NOLEVEL", u8"There is no level currently created " } },
{ LibCmo::CK2::CKERROR::CKERR_CANCREATERENDERCONTEXT, { "CKERR_CANCREATERENDERCONTEXT", " " } }, { LibCmo::CK2::CKERROR::CKERR_CANCREATERENDERCONTEXT, { u8"CKERR_CANCREATERENDERCONTEXT", u8" " } },
{ LibCmo::CK2::CKERROR::CKERR_NOTIFICATIONNOTHANDLED, { "CKERR_NOTIFICATIONNOTHANDLED", "The notification message was not used " } }, { LibCmo::CK2::CKERROR::CKERR_NOTIFICATIONNOTHANDLED, { u8"CKERR_NOTIFICATIONNOTHANDLED", u8"The notification message was not used " } },
{ LibCmo::CK2::CKERROR::CKERR_ALREADYPRESENT, { "CKERR_ALREADYPRESENT", "Attempt to add an item that was already present " } }, { LibCmo::CK2::CKERROR::CKERR_ALREADYPRESENT, { u8"CKERR_ALREADYPRESENT", u8"Attempt to add an item that was already present " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDRENDERCONTEXT, { "CKERR_INVALIDRENDERCONTEXT", "the render context is not valid " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDRENDERCONTEXT, { u8"CKERR_INVALIDRENDERCONTEXT", u8"the render context is not valid " } },
{ LibCmo::CK2::CKERROR::CKERR_RENDERCONTEXTINACTIVE, { "CKERR_RENDERCONTEXTINACTIVE", "the render context is not activated for rendering " } }, { LibCmo::CK2::CKERROR::CKERR_RENDERCONTEXTINACTIVE, { u8"CKERR_RENDERCONTEXTINACTIVE", u8"the render context is not activated for rendering " } },
{ LibCmo::CK2::CKERROR::CKERR_NOLOADPLUGINS, { "CKERR_NOLOADPLUGINS", "there was no plugins to load this kind of file " } }, { LibCmo::CK2::CKERROR::CKERR_NOLOADPLUGINS, { u8"CKERR_NOLOADPLUGINS", u8"there was no plugins to load this kind of file " } },
{ LibCmo::CK2::CKERROR::CKERR_NOSAVEPLUGINS, { "CKERR_NOSAVEPLUGINS", "there was no plugins to save this kind of file " } }, { LibCmo::CK2::CKERROR::CKERR_NOSAVEPLUGINS, { u8"CKERR_NOSAVEPLUGINS", u8"there was no plugins to save this kind of file " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDFILE, { "CKERR_INVALIDFILE", "attempt to load an invalid file " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDFILE, { u8"CKERR_INVALIDFILE", u8"attempt to load an invalid file " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDPLUGIN, { "CKERR_INVALIDPLUGIN", "attempt to load with an invalid plugin " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDPLUGIN, { u8"CKERR_INVALIDPLUGIN", u8"attempt to load with an invalid plugin " } },
{ LibCmo::CK2::CKERROR::CKERR_NOTINITIALIZED, { "CKERR_NOTINITIALIZED", "attempt use an object that wasnt initialized " } }, { LibCmo::CK2::CKERROR::CKERR_NOTINITIALIZED, { u8"CKERR_NOTINITIALIZED", u8"attempt use an object that wasnt initialized " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDMESSAGE, { "CKERR_INVALIDMESSAGE", "attempt use a message type that wasn't registred " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDMESSAGE, { u8"CKERR_INVALIDMESSAGE", u8"attempt use a message type that wasn't registred " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDPROTOTYPE, { "CKERR_INVALIDPROTOTYPE", "attempt use an invalid prototype " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDPROTOTYPE, { u8"CKERR_INVALIDPROTOTYPE", u8"attempt use an invalid prototype " } },
{ LibCmo::CK2::CKERROR::CKERR_NODLLFOUND, { "CKERR_NODLLFOUND", "No dll file found in the parse directory " } }, { LibCmo::CK2::CKERROR::CKERR_NODLLFOUND, { u8"CKERR_NODLLFOUND", u8"No dll file found in the parse directory " } },
{ LibCmo::CK2::CKERROR::CKERR_ALREADYREGISTREDDLL, { "CKERR_ALREADYREGISTREDDLL", "this dll has already been registred " } }, { LibCmo::CK2::CKERROR::CKERR_ALREADYREGISTREDDLL, { u8"CKERR_ALREADYREGISTREDDLL", u8"this dll has already been registred " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDDLL, { "CKERR_INVALIDDLL", "this dll does not contain information to create the prototype " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDDLL, { u8"CKERR_INVALIDDLL", u8"this dll does not contain information to create the prototype " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDOBJECT, { "CKERR_INVALIDOBJECT", "Invalid Object (attempt to Get an object from an invalid ID) " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDOBJECT, { u8"CKERR_INVALIDOBJECT", u8"Invalid Object (attempt to Get an object from an invalid ID) " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDCONDSOLEWINDOW, { "CKERR_INVALIDCONDSOLEWINDOW", "Invalid window was provided as console window " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDCONDSOLEWINDOW, { u8"CKERR_INVALIDCONDSOLEWINDOW", u8"Invalid window was provided as console window " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDKINEMATICCHAIN, { "CKERR_INVALIDKINEMATICCHAIN", "Invalid kinematic chain ( end and start effector may not be part of the same hierarchy ) " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDKINEMATICCHAIN, { u8"CKERR_INVALIDKINEMATICCHAIN", u8"Invalid kinematic chain ( end and start effector may not be part of the same hierarchy ) " } },
{ LibCmo::CK2::CKERROR::CKERR_NOKEYBOARD, { "CKERR_NOKEYBOARD", "Keyboard not attached or not working properly " } }, { LibCmo::CK2::CKERROR::CKERR_NOKEYBOARD, { u8"CKERR_NOKEYBOARD", u8"Keyboard not attached or not working properly " } },
{ LibCmo::CK2::CKERROR::CKERR_NOMOUSE, { "CKERR_NOMOUSE", "Mouse not attached or not working properly " } }, { LibCmo::CK2::CKERROR::CKERR_NOMOUSE, { u8"CKERR_NOMOUSE", u8"Mouse not attached or not working properly " } },
{ LibCmo::CK2::CKERROR::CKERR_NOJOYSTICK, { "CKERR_NOJOYSTICK", "Joystick not attached or not working properly " } }, { LibCmo::CK2::CKERROR::CKERR_NOJOYSTICK, { u8"CKERR_NOJOYSTICK", u8"Joystick not attached or not working properly " } },
{ LibCmo::CK2::CKERROR::CKERR_INCOMPATIBLEPARAMETERS, { "CKERR_INCOMPATIBLEPARAMETERS", "Try to link imcompatible Parameters " } }, { LibCmo::CK2::CKERROR::CKERR_INCOMPATIBLEPARAMETERS, { u8"CKERR_INCOMPATIBLEPARAMETERS", u8"Try to link imcompatible Parameters " } },
{ LibCmo::CK2::CKERROR::CKERR_NORENDERENGINE, { "CKERR_NORENDERENGINE", "There is no render engine dll " } }, { LibCmo::CK2::CKERROR::CKERR_NORENDERENGINE, { u8"CKERR_NORENDERENGINE", u8"There is no render engine dll " } },
{ LibCmo::CK2::CKERROR::CKERR_NOCURRENTLEVEL, { "CKERR_NOCURRENTLEVEL", "There is no current level (use CKSetCurrentLevel ) " } }, { LibCmo::CK2::CKERROR::CKERR_NOCURRENTLEVEL, { u8"CKERR_NOCURRENTLEVEL", u8"There is no current level (use CKSetCurrentLevel ) " } },
{ LibCmo::CK2::CKERROR::CKERR_SOUNDDISABLED, { "CKERR_SOUNDDISABLED", "Sound Management has been disabled " } }, { LibCmo::CK2::CKERROR::CKERR_SOUNDDISABLED, { u8"CKERR_SOUNDDISABLED", u8"Sound Management has been disabled " } },
{ LibCmo::CK2::CKERROR::CKERR_DINPUTDISABLED, { "CKERR_DINPUTDISABLED", "DirectInput Management has been disabled " } }, { LibCmo::CK2::CKERROR::CKERR_DINPUTDISABLED, { u8"CKERR_DINPUTDISABLED", u8"DirectInput Management has been disabled " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDGUID, { "CKERR_INVALIDGUID", "Guid is already in use or invalid " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDGUID, { u8"CKERR_INVALIDGUID", u8"Guid is already in use or invalid " } },
{ LibCmo::CK2::CKERROR::CKERR_NOTENOUGHDISKPLACE, { "CKERR_NOTENOUGHDISKPLACE", "There was no more free space on disk when trying to save a file " } }, { LibCmo::CK2::CKERROR::CKERR_NOTENOUGHDISKPLACE, { u8"CKERR_NOTENOUGHDISKPLACE", u8"There was no more free space on disk when trying to save a file " } },
{ LibCmo::CK2::CKERROR::CKERR_CANTWRITETOFILE, { "CKERR_CANTWRITETOFILE", "Impossible to write to file (write-protection ?) " } }, { LibCmo::CK2::CKERROR::CKERR_CANTWRITETOFILE, { u8"CKERR_CANTWRITETOFILE", u8"Impossible to write to file (write-protection ?) " } },
{ LibCmo::CK2::CKERROR::CKERR_BEHAVIORADDDENIEDBYCB, { "CKERR_BEHAVIORADDDENIEDBYCB", "The behavior cannnot be added to this entity " } }, { LibCmo::CK2::CKERROR::CKERR_BEHAVIORADDDENIEDBYCB, { u8"CKERR_BEHAVIORADDDENIEDBYCB", u8"The behavior cannnot be added to this entity " } },
{ LibCmo::CK2::CKERROR::CKERR_INCOMPATIBLECLASSID, { "CKERR_INCOMPATIBLECLASSID", "The behavior cannnot be added to this entity " } }, { LibCmo::CK2::CKERROR::CKERR_INCOMPATIBLECLASSID, { u8"CKERR_INCOMPATIBLECLASSID", u8"The behavior cannnot be added to this entity " } },
{ LibCmo::CK2::CKERROR::CKERR_MANAGERALREADYEXISTS, { "CKERR_MANAGERALREADYEXISTS", "A manager was registered more than once " } }, { LibCmo::CK2::CKERROR::CKERR_MANAGERALREADYEXISTS, { u8"CKERR_MANAGERALREADYEXISTS", u8"A manager was registered more than once " } },
{ LibCmo::CK2::CKERROR::CKERR_PAUSED, { "CKERR_PAUSED", "CKprocess or TimeManager process while CK is paused will fail " } }, { LibCmo::CK2::CKERROR::CKERR_PAUSED, { u8"CKERR_PAUSED", u8"CKprocess or TimeManager process while CK is paused will fail " } },
{ LibCmo::CK2::CKERROR::CKERR_PLUGINSMISSING, { "CKERR_PLUGINSMISSING", "Some plugins were missing whileloading a file " } }, { LibCmo::CK2::CKERROR::CKERR_PLUGINSMISSING, { u8"CKERR_PLUGINSMISSING", u8"Some plugins were missing whileloading a file " } },
{ LibCmo::CK2::CKERROR::CKERR_OBSOLETEVIRTOOLS, { "CKERR_OBSOLETEVIRTOOLS", "Virtools version too old to load this file " } }, { LibCmo::CK2::CKERROR::CKERR_OBSOLETEVIRTOOLS, { u8"CKERR_OBSOLETEVIRTOOLS", u8"Virtools version too old to load this file " } },
{ LibCmo::CK2::CKERROR::CKERR_FILECRCERROR, { "CKERR_FILECRCERROR", "CRC Error while loading file " } }, { LibCmo::CK2::CKERROR::CKERR_FILECRCERROR, { u8"CKERR_FILECRCERROR", u8"CRC Error while loading file " } },
{ LibCmo::CK2::CKERROR::CKERR_ALREADYFULLSCREEN, { "CKERR_ALREADYFULLSCREEN", "A Render context is already in Fullscreen Mode " } }, { LibCmo::CK2::CKERROR::CKERR_ALREADYFULLSCREEN, { u8"CKERR_ALREADYFULLSCREEN", u8"A Render context is already in Fullscreen Mode " } },
{ LibCmo::CK2::CKERROR::CKERR_CANCELLED, { "CKERR_CANCELLED", "Operation was cancelled by user " } }, { LibCmo::CK2::CKERROR::CKERR_CANCELLED, { u8"CKERR_CANCELLED", u8"Operation was cancelled by user " } },
{ LibCmo::CK2::CKERROR::CKERR_NOANIMATIONKEY, { "CKERR_NOANIMATIONKEY", "there were no animation key at the given index " } }, { LibCmo::CK2::CKERROR::CKERR_NOANIMATIONKEY, { u8"CKERR_NOANIMATIONKEY", u8"there were no animation key at the given index " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDINDEX, { "CKERR_INVALIDINDEX", "attemp to acces an animation key with an invalid index " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDINDEX, { u8"CKERR_INVALIDINDEX", u8"attemp to acces an animation key with an invalid index " } },
{ LibCmo::CK2::CKERROR::CKERR_INVALIDANIMATION, { "CKERR_INVALIDANIMATION", "the animation is invalid (no entity associated or zero length) " } }, { LibCmo::CK2::CKERROR::CKERR_INVALIDANIMATION, { u8"CKERR_INVALIDANIMATION", u8"the animation is invalid (no entity associated or zero length) " } },
}; };
} }
@ -196,13 +174,13 @@ namespace Unvirt::AccessibleValue {
return nullptr; return nullptr;
} }
std::string GetCkErrorName(LibCmo::CK2::CKERROR err) { std::u8string GetCkErrorName(LibCmo::CK2::CKERROR err) {
const CkErrorReflection* node = GetCkError(err); const CkErrorReflection* node = GetCkError(err);
if (node != nullptr) return node->mName; if (node != nullptr) return node->mName;
else return c_InvalidEnumName; else return c_InvalidEnumName;
} }
std::string GetCkErrorDescription(LibCmo::CK2::CKERROR err) { std::u8string GetCkErrorDescription(LibCmo::CK2::CKERROR err) {
const CkErrorReflection* node = GetCkError(err); const CkErrorReflection* node = GetCkError(err);
if (node != nullptr) return node->mDescription; if (node != nullptr) return node->mDescription;
else return c_InvalidEnumName; else return c_InvalidEnumName;
@ -217,22 +195,22 @@ namespace Unvirt::AccessibleValue {
return nullptr; return nullptr;
} }
std::string GetClassIdName(LibCmo::CK2::CK_CLASSID cls) { std::u8string GetClassIdName(LibCmo::CK2::CK_CLASSID cls) {
const CkClassidReflection* node = GetCkClassid(cls); const CkClassidReflection* node = GetCkClassid(cls);
if (node == nullptr) return c_InvalidEnumName; if (node == nullptr) return c_InvalidEnumName;
else return node->mHierarchy.back(); else return node->mHierarchy.back();
} }
std::string GetClassIdHierarchy(LibCmo::CK2::CK_CLASSID cls) { std::u8string GetClassIdHierarchy(LibCmo::CK2::CK_CLASSID cls) {
const CkClassidReflection* node = GetCkClassid(cls); const CkClassidReflection* node = GetCkClassid(cls);
if (node == nullptr) return c_InvalidEnumName; if (node == nullptr) return c_InvalidEnumName;
std::string strl; std::u8string ret;
for (auto& hierarchy_node : node->mHierarchy) { for (const auto* hierarchy_node : node->mHierarchy) {
if (!strl.empty()) strl += " -> "; if (!ret.empty()) ret += u8" -> ";
strl += hierarchy_node; ret += hierarchy_node;
} }
return strl; return ret;
} }
#pragma endregion #pragma endregion
@ -241,285 +219,350 @@ namespace Unvirt::AccessibleValue {
namespace EnumDesc { namespace EnumDesc {
const GeneralReflectionArray<LibCmo::CK2::CK_FILE_WRITEMODE> CK_FILE_WRITEMODE {
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_UNCOMPRESSED, { u8"CKFILE_UNCOMPRESSED" } },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_CHUNKCOMPRESSED_OLD, { u8"CKFILE_CHUNKCOMPRESSED_OLD" } },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_EXTERNALTEXTURES_OLD, { u8"CKFILE_EXTERNALTEXTURES_OLD" } },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_FORVIEWER, { u8"CKFILE_FORVIEWER" } },
{ LibCmo::CK2::CK_FILE_WRITEMODE::CKFILE_WHOLECOMPRESSED, { u8"CKFILE_WHOLECOMPRESSED" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_LOAD_FLAGS> CK_LOAD_FLAGS {
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ANIMATION, { u8"CK_LOAD_ANIMATION" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_GEOMETRY, { u8"CK_LOAD_GEOMETRY" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_DEFAULT, { u8"CK_LOAD_DEFAULT" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ASCHARACTER, { u8"CK_LOAD_ASCHARACTER" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_DODIALOG, { u8"CK_LOAD_DODIALOG" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_AS_DYNAMIC_OBJECT, { u8"CK_LOAD_AS_DYNAMIC_OBJECT" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_AUTOMATICMODE, { u8"CK_LOAD_AUTOMATICMODE" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_CHECKDUPLICATES, { u8"CK_LOAD_CHECKDUPLICATES" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_CHECKDEPENDENCIES, { u8"CK_LOAD_CHECKDEPENDENCIES" } },
{ LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ONLYBEHAVIORS, { u8"CK_LOAD_ONLYBEHAVIORS" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_FO_OPTIONS> CK_FO_OPTIONS { const GeneralReflectionArray<LibCmo::CK2::CK_FO_OPTIONS> CK_FO_OPTIONS {
{ LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DEFAULT, {"CK_FO_DEFAULT"} }, { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DEFAULT, { u8"CK_FO_DEFAULT" } },
{ LibCmo::CK2::CK_FO_OPTIONS::CK_FO_RENAMEOBJECT, {"CK_FO_RENAMEOBJECT"} }, { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_RENAMEOBJECT, { u8"CK_FO_RENAMEOBJECT" } },
{ LibCmo::CK2::CK_FO_OPTIONS::CK_FO_REPLACEOBJECT, {"CK_FO_REPLACEOBJECT"} }, { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_REPLACEOBJECT, { u8"CK_FO_REPLACEOBJECT" } },
{ LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DONTLOADOBJECT, {"CK_FO_DONTLOADOBJECT"} }, { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DONTLOADOBJECT, { u8"CK_FO_DONTLOADOBJECT" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_LOADMODE> CK_LOADMODE {
{ LibCmo::CK2::CK_LOADMODE::CKLOAD_INVALID, { u8"CKLOAD_INVALID" } },
{ LibCmo::CK2::CK_LOADMODE::CKLOAD_OK, { u8"CKLOAD_OK" } },
{ LibCmo::CK2::CK_LOADMODE::CKLOAD_REPLACE, { u8"CKLOAD_REPLACE" } },
{ LibCmo::CK2::CK_LOADMODE::CKLOAD_RENAME, { u8"CKLOAD_RENAME" } },
{ LibCmo::CK2::CK_LOADMODE::CKLOAD_USECURRENT, { u8"CKLOAD_USECURRENT" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_OBJECTCREATION_OPTIONS> CK_OBJECTCREATION_OPTIONS {
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_NONAMECHECK, { u8"CK_OBJECTCREATION_NONAMECHECK" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_REPLACE, { u8"CK_OBJECTCREATION_REPLACE" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_RENAME, { u8"CK_OBJECTCREATION_RENAME" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_USECURRENT, { u8"CK_OBJECTCREATION_USECURRENT" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_ASK, { u8"CK_OBJECTCREATION_ASK" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_FLAGSMASK, { u8"CK_OBJECTCREATION_FLAGSMASK" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_DYNAMIC, { u8"CK_OBJECTCREATION_DYNAMIC" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_ACTIVATE, { u8"CK_OBJECTCREATION_ACTIVATE" } },
{ LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_NONAMECOPY, { u8"CK_OBJECTCREATION_NONAMECOPY" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_PLUGIN_TYPE> CK_PLUGIN_TYPE {
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_BITMAP_READER, { u8"CKPLUGIN_BITMAP_READER" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_SOUND_READER, { u8"CKPLUGIN_SOUND_READER" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MODEL_READER, { u8"CKPLUGIN_MODEL_READER" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MANAGER_DLL, { u8"CKPLUGIN_MANAGER_DLL" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_BEHAVIOR_DLL, { u8"CKPLUGIN_BEHAVIOR_DLL" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_RENDERENGINE_DLL, { u8"CKPLUGIN_RENDERENGINE_DLL" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MOVIE_READER, { u8"CKPLUGIN_MOVIE_READER" } },
{ LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_EXTENSION_DLL, { u8"CKPLUGIN_EXTENSION_DLL" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS> CK_STATECHUNK_CHUNKOPTIONS { const GeneralReflectionArray<LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS> CK_STATECHUNK_CHUNKOPTIONS {
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_IDS, {"CHNK_OPTION_IDS"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_IDS, { u8"CHNK_OPTION_IDS" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_MAN, {"CHNK_OPTION_MAN"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_MAN, { u8"CHNK_OPTION_MAN" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_CHN, {"CHNK_OPTION_CHN"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_CHN, { u8"CHNK_OPTION_CHN" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_FILE, {"CHNK_OPTION_FILE"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_FILE, { u8"CHNK_OPTION_FILE" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_ALLOWDYN, {"CHNK_OPTION_ALLOWDYN"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_ALLOWDYN, { u8"CHNK_OPTION_ALLOWDYN" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_LISTBIG, {"CHNK_OPTION_LISTBIG"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_LISTBIG, { u8"CHNK_OPTION_LISTBIG" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_DONTDELETE_PTR, {"CHNK_DONTDELETE_PTR"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_DONTDELETE_PTR, { u8"CHNK_DONTDELETE_PTR" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_DONTDELETE_PARSER, {"CHNK_DONTDELETE_PARSER"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_DONTDELETE_PARSER, { u8"CHNK_DONTDELETE_PARSER" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_STATECHUNK_DATAVERSION> CK_STATECHUNK_DATAVERSION { const GeneralReflectionArray<LibCmo::CK2::CK_STATECHUNK_DATAVERSION> CK_STATECHUNK_DATAVERSION {
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_OLDVERSION, {"CHUNKDATA_OLDVERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_OLDVERSION, { u8"CHUNKDATA_OLDVERSION" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_BASEVERSION, {"CHUNKDATA_BASEVERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_BASEVERSION, { u8"CHUNKDATA_BASEVERSION" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION2, {"CHUNK_WAVESOUND_VERSION2"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION2, { u8"CHUNK_WAVESOUND_VERSION2" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION3, {"CHUNK_WAVESOUND_VERSION3"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION3, { u8"CHUNK_WAVESOUND_VERSION3" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MATERIAL_VERSION_ZTEST, {"CHUNK_MATERIAL_VERSION_ZTEST"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MATERIAL_VERSION_ZTEST, { u8"CHUNK_MATERIAL_VERSION_ZTEST" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MAJORCHANGE_VERSION, {"CHUNK_MAJORCHANGE_VERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MAJORCHANGE_VERSION, { u8"CHUNK_MAJORCHANGE_VERSION" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MACCHANGE_VERSION, {"CHUNK_MACCHANGE_VERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MACCHANGE_VERSION, { u8"CHUNK_MACCHANGE_VERSION" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION4, {"CHUNK_WAVESOUND_VERSION4"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION4, { u8"CHUNK_WAVESOUND_VERSION4" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_SCENECHANGE_VERSION, {"CHUNK_SCENECHANGE_VERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_SCENECHANGE_VERSION, { u8"CHUNK_SCENECHANGE_VERSION" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MESHCHANGE_VERSION, {"CHUNK_MESHCHANGE_VERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MESHCHANGE_VERSION, { u8"CHUNK_MESHCHANGE_VERSION" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_DEV_2_1, {"CHUNK_DEV_2_1"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_DEV_2_1, { u8"CHUNK_DEV_2_1" } },
{ LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_CURRENTVERSION, {"CHUNKDATA_CURRENTVERSION"} }, { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_CURRENTVERSION, { u8"CHUNKDATA_CURRENTVERSION" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION> CK_STATECHUNK_CHUNKVERSION { const GeneralReflectionArray<LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION> CK_STATECHUNK_CHUNKVERSION {
{ LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSIONBASE, {"CHUNK_VERSIONBASE"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSIONBASE, { u8"CHUNK_VERSIONBASE" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION1, {"CHUNK_VERSION1"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION1, { u8"CHUNK_VERSION1" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION2, {"CHUNK_VERSION2"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION2, { u8"CHUNK_VERSION2" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION3, {"CHUNK_VERSION3"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION3, { u8"CHUNK_VERSION3" } },
{ LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4, {"CHUNK_VERSION4"} }, { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4, { u8"CHUNK_VERSION4" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_OBJECT_SHOWOPTION> CK_OBJECT_SHOWOPTION {
{ LibCmo::CK2::CK_OBJECT_SHOWOPTION::CKHIDE, { u8"CKHIDE" } },
{ LibCmo::CK2::CK_OBJECT_SHOWOPTION::CKSHOW, { u8"CKSHOW" } },
{ LibCmo::CK2::CK_OBJECT_SHOWOPTION::CKHIERARCHICALHIDE, { u8"CKHIERARCHICALHIDE" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_OBJECT_FLAGS> CK_OBJECT_FLAGS { const GeneralReflectionArray<LibCmo::CK2::CK_OBJECT_FLAGS> CK_OBJECT_FLAGS {
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_INTERFACEOBJ, {"CK_OBJECT_INTERFACEOBJ"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_INTERFACEOBJ, { u8"CK_OBJECT_INTERFACEOBJ" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_PRIVATE, {"CK_OBJECT_PRIVATE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_PRIVATE, { u8"CK_OBJECT_PRIVATE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_INTERFACEMARK, {"CK_OBJECT_INTERFACEMARK"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_INTERFACEMARK, { u8"CK_OBJECT_INTERFACEMARK" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_FREEID, {"CK_OBJECT_FREEID"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_FREEID, { u8"CK_OBJECT_FREEID" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_TOBEDELETED, {"CK_OBJECT_TOBEDELETED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_TOBEDELETED, { u8"CK_OBJECT_TOBEDELETED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBESAVED, {"CK_OBJECT_NOTTOBESAVED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBESAVED, { u8"CK_OBJECT_NOTTOBESAVED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_VISIBLE, {"CK_OBJECT_VISIBLE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_VISIBLE, { u8"CK_OBJECT_VISIBLE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NAMESHARED, {"CK_OBJECT_NAMESHARED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NAMESHARED, { u8"CK_OBJECT_NAMESHARED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_DYNAMIC, {"CK_OBJECT_DYNAMIC"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_DYNAMIC, { u8"CK_OBJECT_DYNAMIC" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_HIERACHICALHIDE, {"CK_OBJECT_HIERACHICALHIDE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_HIERACHICALHIDE, { u8"CK_OBJECT_HIERACHICALHIDE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_UPTODATE, {"CK_OBJECT_UPTODATE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_UPTODATE, { u8"CK_OBJECT_UPTODATE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_TEMPMARKER, {"CK_OBJECT_TEMPMARKER"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_TEMPMARKER, { u8"CK_OBJECT_TEMPMARKER" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_ONLYFORFILEREFERENCE, {"CK_OBJECT_ONLYFORFILEREFERENCE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_ONLYFORFILEREFERENCE, { u8"CK_OBJECT_ONLYFORFILEREFERENCE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBEDELETED, {"CK_OBJECT_NOTTOBEDELETED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBEDELETED, { u8"CK_OBJECT_NOTTOBEDELETED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_APPDATA, {"CK_OBJECT_APPDATA"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_APPDATA, { u8"CK_OBJECT_APPDATA" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_SINGLEACTIVITY, {"CK_OBJECT_SINGLEACTIVITY"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_SINGLEACTIVITY, { u8"CK_OBJECT_SINGLEACTIVITY" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_LOADSKIPBEOBJECT, {"CK_OBJECT_LOADSKIPBEOBJECT"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_LOADSKIPBEOBJECT, { u8"CK_OBJECT_LOADSKIPBEOBJECT" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBELISTEDANDSAVED, {"CK_OBJECT_NOTTOBELISTEDANDSAVED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBELISTEDANDSAVED, { u8"CK_OBJECT_NOTTOBELISTEDANDSAVED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_SETTINGS, {"CK_PARAMETEROUT_SETTINGS"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_SETTINGS, { u8"CK_PARAMETEROUT_SETTINGS" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_PARAMOP, {"CK_PARAMETEROUT_PARAMOP"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_PARAMOP, { u8"CK_PARAMETEROUT_PARAMOP" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_DISABLED, {"CK_PARAMETERIN_DISABLED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_DISABLED, { u8"CK_PARAMETERIN_DISABLED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_THIS, {"CK_PARAMETERIN_THIS"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_THIS, { u8"CK_PARAMETERIN_THIS" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_SHARED, {"CK_PARAMETERIN_SHARED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_SHARED, { u8"CK_PARAMETERIN_SHARED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_DELETEAFTERUSE, {"CK_PARAMETEROUT_DELETEAFTERUSE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_DELETEAFTERUSE, { u8"CK_PARAMETEROUT_DELETEAFTERUSE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_PARAMMASK, {"CK_OBJECT_PARAMMASK"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_PARAMMASK, { u8"CK_OBJECT_PARAMMASK" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_IN, {"CK_BEHAVIORIO_IN"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_IN, { u8"CK_BEHAVIORIO_IN" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_OUT, {"CK_BEHAVIORIO_OUT"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_OUT, { u8"CK_BEHAVIORIO_OUT" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_ACTIVE, {"CK_BEHAVIORIO_ACTIVE"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_ACTIVE, { u8"CK_BEHAVIORIO_ACTIVE" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_IOTYPEMASK, {"CK_OBJECT_IOTYPEMASK"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_IOTYPEMASK, { u8"CK_OBJECT_IOTYPEMASK" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_IOMASK, {"CK_OBJECT_IOMASK"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_IOMASK, { u8"CK_OBJECT_IOMASK" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CKBEHAVIORLINK_RESERVED, {"CKBEHAVIORLINK_RESERVED"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CKBEHAVIORLINK_RESERVED, { u8"CKBEHAVIORLINK_RESERVED" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CKBEHAVIORLINK_ACTIVATEDLASTFRAME, {"CKBEHAVIORLINK_ACTIVATEDLASTFRAME"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CKBEHAVIORLINK_ACTIVATEDLASTFRAME, { u8"CKBEHAVIORLINK_ACTIVATEDLASTFRAME" } },
{ LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_BEHAVIORLINKMASK, {"CK_OBJECT_BEHAVIORLINKMASK"} }, { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_BEHAVIORLINKMASK, { u8"CK_OBJECT_BEHAVIORLINKMASK" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_3DENTITY_FLAGS> CK_3DENTITY_FLAGS { const GeneralReflectionArray<LibCmo::CK2::CK_3DENTITY_FLAGS> CK_3DENTITY_FLAGS {
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_DUMMY, {"CK_3DENTITY_DUMMY"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_DUMMY, { u8"CK_3DENTITY_DUMMY" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_FRAME, {"CK_3DENTITY_FRAME"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_FRAME, { u8"CK_3DENTITY_FRAME" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_RESERVED0, {"CK_3DENTITY_RESERVED0"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_RESERVED0, { u8"CK_3DENTITY_RESERVED0" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_TARGETLIGHT, {"CK_3DENTITY_TARGETLIGHT"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_TARGETLIGHT, { u8"CK_3DENTITY_TARGETLIGHT" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_TARGETCAMERA, {"CK_3DENTITY_TARGETCAMERA"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_TARGETCAMERA, { u8"CK_3DENTITY_TARGETCAMERA" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_IGNOREANIMATION, {"CK_3DENTITY_IGNOREANIMATION"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_IGNOREANIMATION, { u8"CK_3DENTITY_IGNOREANIMATION" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_HIERARCHICALOBSTACLE, {"CK_3DENTITY_HIERARCHICALOBSTACLE"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_HIERARCHICALOBSTACLE, { u8"CK_3DENTITY_HIERARCHICALOBSTACLE" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_UPDATELASTFRAME, {"CK_3DENTITY_UPDATELASTFRAME"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_UPDATELASTFRAME, { u8"CK_3DENTITY_UPDATELASTFRAME" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_CAMERAIGNOREASPECT, {"CK_3DENTITY_CAMERAIGNOREASPECT"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_CAMERAIGNOREASPECT, { u8"CK_3DENTITY_CAMERAIGNOREASPECT" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_DISABLESKINPROCESS, {"CK_3DENTITY_DISABLESKINPROCESS"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_DISABLESKINPROCESS, { u8"CK_3DENTITY_DISABLESKINPROCESS" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_ENABLESKINOFFSET, {"CK_3DENTITY_ENABLESKINOFFSET"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_ENABLESKINOFFSET, { u8"CK_3DENTITY_ENABLESKINOFFSET" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_PLACEVALID, {"CK_3DENTITY_PLACEVALID"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_PLACEVALID, { u8"CK_3DENTITY_PLACEVALID" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_PARENTVALID, {"CK_3DENTITY_PARENTVALID"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_PARENTVALID, { u8"CK_3DENTITY_PARENTVALID" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_IKJOINTVALID, {"CK_3DENTITY_IKJOINTVALID"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_IKJOINTVALID, { u8"CK_3DENTITY_IKJOINTVALID" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_PORTAL, {"CK_3DENTITY_PORTAL"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_PORTAL, { u8"CK_3DENTITY_PORTAL" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_ZORDERVALID, {"CK_3DENTITY_ZORDERVALID"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_ZORDERVALID, { u8"CK_3DENTITY_ZORDERVALID" } },
{ LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_CHARACTERDOPROCESS, {"CK_3DENTITY_CHARACTERDOPROCESS"} }, { LibCmo::CK2::CK_3DENTITY_FLAGS::CK_3DENTITY_CHARACTERDOPROCESS, { u8"CK_3DENTITY_CHARACTERDOPROCESS" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS> CK_TEXTURE_SAVEOPTIONS { const GeneralReflectionArray<LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS> CK_TEXTURE_SAVEOPTIONS {
{ LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_RAWDATA, {"CKTEXTURE_RAWDATA"} }, { LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_RAWDATA, { u8"CKTEXTURE_RAWDATA" } },
{ LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_EXTERNAL, {"CKTEXTURE_EXTERNAL"} }, { LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_EXTERNAL, { u8"CKTEXTURE_EXTERNAL" } },
{ LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_IMAGEFORMAT, {"CKTEXTURE_IMAGEFORMAT"} }, { LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_IMAGEFORMAT, { u8"CKTEXTURE_IMAGEFORMAT" } },
{ LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_USEGLOBAL, {"CKTEXTURE_USEGLOBAL"} }, { LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_USEGLOBAL, { u8"CKTEXTURE_USEGLOBAL" } },
{ LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_INCLUDEORIGINALFILE, {"CKTEXTURE_INCLUDEORIGINALFILE"} }, { LibCmo::CK2::CK_TEXTURE_SAVEOPTIONS::CKTEXTURE_INCLUDEORIGINALFILE, { u8"CKTEXTURE_INCLUDEORIGINALFILE" } },
};
const GeneralReflectionArray<LibCmo::CK2::CK_SOUND_SAVEOPTIONS> CK_SOUND_SAVEOPTIONS {
{ LibCmo::CK2::CK_SOUND_SAVEOPTIONS::CKSOUND_EXTERNAL, { u8"CKSOUND_EXTERNAL" } },
{ LibCmo::CK2::CK_SOUND_SAVEOPTIONS::CKSOUND_INCLUDEORIGINALFILE, { u8"CKSOUND_INCLUDEORIGINALFILE" } },
{ LibCmo::CK2::CK_SOUND_SAVEOPTIONS::CKSOUND_USEGLOBAL, { u8"CKSOUND_USEGLOBAL" } },
}; };
const GeneralReflectionArray<LibCmo::CK2::CK_BITMAPDATA_FLAGS> CK_BITMAPDATA_FLAGS { const GeneralReflectionArray<LibCmo::CK2::CK_BITMAPDATA_FLAGS> CK_BITMAPDATA_FLAGS {
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_INVALID, {"CKBITMAPDATA_INVALID"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_INVALID, { u8"CKBITMAPDATA_INVALID" } },
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_TRANSPARENT, {"CKBITMAPDATA_TRANSPARENT"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_TRANSPARENT, { u8"CKBITMAPDATA_TRANSPARENT" } },
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_FORCERESTORE, {"CKBITMAPDATA_FORCERESTORE"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_FORCERESTORE, { u8"CKBITMAPDATA_FORCERESTORE" } },
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_CLAMPUPTODATE, {"CKBITMAPDATA_CLAMPUPTODATE"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_CLAMPUPTODATE, { u8"CKBITMAPDATA_CLAMPUPTODATE" } },
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_CUBEMAP, {"CKBITMAPDATA_CUBEMAP"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_CUBEMAP, { u8"CKBITMAPDATA_CUBEMAP" } },
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_FREEVIDEOMEMORY, {"CKBITMAPDATA_FREEVIDEOMEMORY"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_FREEVIDEOMEMORY, { u8"CKBITMAPDATA_FREEVIDEOMEMORY" } },
{ LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_DYNAMIC, {"CKBITMAPDATA_DYNAMIC"} }, { LibCmo::CK2::CK_BITMAPDATA_FLAGS::CKBITMAPDATA_DYNAMIC, { u8"CKBITMAPDATA_DYNAMIC" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VX_PIXELFORMAT> VX_PIXELFORMAT { const GeneralReflectionArray<LibCmo::VxMath::VX_PIXELFORMAT> VX_PIXELFORMAT {
{ LibCmo::VxMath::VX_PIXELFORMAT::UNKNOWN_PF, {"UNKNOWN_PF"} }, { LibCmo::VxMath::VX_PIXELFORMAT::UNKNOWN_PF, { u8"UNKNOWN_PF" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_ARGB8888, {"_32_ARGB8888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_ARGB8888, { u8"_32_ARGB8888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_RGB888, {"_32_RGB888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_RGB888, { u8"_32_RGB888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_24_RGB888, {"_24_RGB888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_24_RGB888, { u8"_24_RGB888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_RGB565, {"_16_RGB565"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_RGB565, { u8"_16_RGB565" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_RGB555, {"_16_RGB555"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_RGB555, { u8"_16_RGB555" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_ARGB1555, {"_16_ARGB1555"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_ARGB1555, { u8"_16_ARGB1555" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_ARGB4444, {"_16_ARGB4444"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_ARGB4444, { u8"_16_ARGB4444" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_8_RGB332, {"_8_RGB332"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_8_RGB332, { u8"_8_RGB332" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_8_ARGB2222, {"_8_ARGB2222"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_8_ARGB2222, { u8"_8_ARGB2222" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_ABGR8888, {"_32_ABGR8888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_ABGR8888, { u8"_32_ABGR8888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_RGBA8888, {"_32_RGBA8888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_RGBA8888, { u8"_32_RGBA8888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_BGRA8888, {"_32_BGRA8888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_BGRA8888, { u8"_32_BGRA8888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_BGR888, {"_32_BGR888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_BGR888, { u8"_32_BGR888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_24_BGR888, {"_24_BGR888"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_24_BGR888, { u8"_24_BGR888" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_BGR565, {"_16_BGR565"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_BGR565, { u8"_16_BGR565" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_BGR555, {"_16_BGR555"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_BGR555, { u8"_16_BGR555" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_ABGR1555, {"_16_ABGR1555"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_ABGR1555, { u8"_16_ABGR1555" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_ABGR4444, {"_16_ABGR4444"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_ABGR4444, { u8"_16_ABGR4444" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_DXT1, {"_DXT1"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_DXT1, { u8"_DXT1" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_DXT2, {"_DXT2"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_DXT2, { u8"_DXT2" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_DXT3, {"_DXT3"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_DXT3, { u8"_DXT3" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_DXT4, {"_DXT4"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_DXT4, { u8"_DXT4" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_DXT5, {"_DXT5"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_DXT5, { u8"_DXT5" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_V8U8, {"_16_V8U8"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_V8U8, { u8"_16_V8U8" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_V16U16, {"_32_V16U16"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_V16U16, { u8"_32_V16U16" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_16_L6V5U5, {"_16_L6V5U5"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_16_L6V5U5, { u8"_16_L6V5U5" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_32_X8L8V8U8, {"_32_X8L8V8U8"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_32_X8L8V8U8, { u8"_32_X8L8V8U8" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_8_ABGR8888_CLUT, {"_8_ABGR8888_CLUT"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_8_ABGR8888_CLUT, { u8"_8_ABGR8888_CLUT" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_8_ARGB8888_CLUT, {"_8_ARGB8888_CLUT"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_8_ARGB8888_CLUT, { u8"_8_ARGB8888_CLUT" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_4_ABGR8888_CLUT, {"_4_ABGR8888_CLUT"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_4_ABGR8888_CLUT, { u8"_4_ABGR8888_CLUT" } },
{ LibCmo::VxMath::VX_PIXELFORMAT::_4_ARGB8888_CLUT, {"_4_ARGB8888_CLUT"} }, { LibCmo::VxMath::VX_PIXELFORMAT::_4_ARGB8888_CLUT, { u8"_4_ARGB8888_CLUT" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_BLENDMODE> VXTEXTURE_BLENDMODE { const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_BLENDMODE> VXTEXTURE_BLENDMODE {
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DECAL, {"VXTEXTUREBLEND_DECAL"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DECAL, { u8"VXTEXTUREBLEND_DECAL" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATE, {"VXTEXTUREBLEND_MODULATE"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATE, { u8"VXTEXTUREBLEND_MODULATE" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DECALALPHA, {"VXTEXTUREBLEND_DECALALPHA"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DECALALPHA, { u8"VXTEXTUREBLEND_DECALALPHA" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATEALPHA, {"VXTEXTUREBLEND_MODULATEALPHA"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATEALPHA, { u8"VXTEXTUREBLEND_MODULATEALPHA" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DECALMASK, {"VXTEXTUREBLEND_DECALMASK"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DECALMASK, { u8"VXTEXTUREBLEND_DECALMASK" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATEMASK, {"VXTEXTUREBLEND_MODULATEMASK"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MODULATEMASK, { u8"VXTEXTUREBLEND_MODULATEMASK" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_COPY, {"VXTEXTUREBLEND_COPY"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_COPY, { u8"VXTEXTUREBLEND_COPY" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_ADD, {"VXTEXTUREBLEND_ADD"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_ADD, { u8"VXTEXTUREBLEND_ADD" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DOTPRODUCT3, {"VXTEXTUREBLEND_DOTPRODUCT3"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_DOTPRODUCT3, { u8"VXTEXTUREBLEND_DOTPRODUCT3" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MAX, {"VXTEXTUREBLEND_MAX"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MAX, { u8"VXTEXTUREBLEND_MAX" } },
{ LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MASK, {"VXTEXTUREBLEND_MASK"} }, { LibCmo::VxMath::VXTEXTURE_BLENDMODE::VXTEXTUREBLEND_MASK, { u8"VXTEXTUREBLEND_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_FILTERMODE> VXTEXTURE_FILTERMODE { const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_FILTERMODE> VXTEXTURE_FILTERMODE {
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_NEAREST, {"VXTEXTUREFILTER_NEAREST"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_NEAREST, { u8"VXTEXTUREFILTER_NEAREST" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEAR, {"VXTEXTUREFILTER_LINEAR"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEAR, { u8"VXTEXTUREFILTER_LINEAR" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_MIPNEAREST, {"VXTEXTUREFILTER_MIPNEAREST"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_MIPNEAREST, { u8"VXTEXTUREFILTER_MIPNEAREST" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_MIPLINEAR, {"VXTEXTUREFILTER_MIPLINEAR"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_MIPLINEAR, { u8"VXTEXTUREFILTER_MIPLINEAR" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEARMIPNEAREST, {"VXTEXTUREFILTER_LINEARMIPNEAREST"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEARMIPNEAREST, { u8"VXTEXTUREFILTER_LINEARMIPNEAREST" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEARMIPLINEAR, {"VXTEXTUREFILTER_LINEARMIPLINEAR"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_LINEARMIPLINEAR, { u8"VXTEXTUREFILTER_LINEARMIPLINEAR" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_ANISOTROPIC, {"VXTEXTUREFILTER_ANISOTROPIC"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_ANISOTROPIC, { u8"VXTEXTUREFILTER_ANISOTROPIC" } },
{ LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_MASK, {"VXTEXTUREFILTER_MASK"} }, { LibCmo::VxMath::VXTEXTURE_FILTERMODE::VXTEXTUREFILTER_MASK, { u8"VXTEXTUREFILTER_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXBLEND_MODE> VXBLEND_MODE { const GeneralReflectionArray<LibCmo::VxMath::VXBLEND_MODE> VXBLEND_MODE {
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_ZERO, {"VXBLEND_ZERO"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_ZERO, { u8"VXBLEND_ZERO" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_ONE, {"VXBLEND_ONE"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_ONE, { u8"VXBLEND_ONE" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_SRCCOLOR, {"VXBLEND_SRCCOLOR"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_SRCCOLOR, { u8"VXBLEND_SRCCOLOR" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVSRCCOLOR, {"VXBLEND_INVSRCCOLOR"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVSRCCOLOR, { u8"VXBLEND_INVSRCCOLOR" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_SRCALPHA, {"VXBLEND_SRCALPHA"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_SRCALPHA, { u8"VXBLEND_SRCALPHA" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVSRCALPHA, {"VXBLEND_INVSRCALPHA"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVSRCALPHA, { u8"VXBLEND_INVSRCALPHA" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_DESTALPHA, {"VXBLEND_DESTALPHA"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_DESTALPHA, { u8"VXBLEND_DESTALPHA" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVDESTALPHA, {"VXBLEND_INVDESTALPHA"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVDESTALPHA, { u8"VXBLEND_INVDESTALPHA" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_DESTCOLOR, {"VXBLEND_DESTCOLOR"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_DESTCOLOR, { u8"VXBLEND_DESTCOLOR" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVDESTCOLOR, {"VXBLEND_INVDESTCOLOR"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_INVDESTCOLOR, { u8"VXBLEND_INVDESTCOLOR" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_SRCALPHASAT, {"VXBLEND_SRCALPHASAT"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_SRCALPHASAT, { u8"VXBLEND_SRCALPHASAT" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_BOTHSRCALPHA, {"VXBLEND_BOTHSRCALPHA"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_BOTHSRCALPHA, { u8"VXBLEND_BOTHSRCALPHA" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_BOTHINVSRCALPHA, {"VXBLEND_BOTHINVSRCALPHA"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_BOTHINVSRCALPHA, { u8"VXBLEND_BOTHINVSRCALPHA" } },
{ LibCmo::VxMath::VXBLEND_MODE::VXBLEND_MASK, {"VXBLEND_MASK"} }, { LibCmo::VxMath::VXBLEND_MODE::VXBLEND_MASK, { u8"VXBLEND_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_ADDRESSMODE> VXTEXTURE_ADDRESSMODE { const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_ADDRESSMODE> VXTEXTURE_ADDRESSMODE {
{ LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSWRAP, {"VXTEXTURE_ADDRESSWRAP"} }, { LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSWRAP, { u8"VXTEXTURE_ADDRESSWRAP" } },
{ LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSMIRROR, {"VXTEXTURE_ADDRESSMIRROR"} }, { LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSMIRROR, { u8"VXTEXTURE_ADDRESSMIRROR" } },
{ LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSCLAMP, {"VXTEXTURE_ADDRESSCLAMP"} }, { LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSCLAMP, { u8"VXTEXTURE_ADDRESSCLAMP" } },
{ LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSBORDER, {"VXTEXTURE_ADDRESSBORDER"} }, { LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSBORDER, { u8"VXTEXTURE_ADDRESSBORDER" } },
{ LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSMIRRORONCE, {"VXTEXTURE_ADDRESSMIRRORONCE"} }, { LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSMIRRORONCE, { u8"VXTEXTURE_ADDRESSMIRRORONCE" } },
{ LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSMASK, {"VXTEXTURE_ADDRESSMASK"} }, { LibCmo::VxMath::VXTEXTURE_ADDRESSMODE::VXTEXTURE_ADDRESSMASK, { u8"VXTEXTURE_ADDRESSMASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXFILL_MODE> VXFILL_MODE { const GeneralReflectionArray<LibCmo::VxMath::VXFILL_MODE> VXFILL_MODE {
{ LibCmo::VxMath::VXFILL_MODE::VXFILL_POINT, {"VXFILL_POINT"} }, { LibCmo::VxMath::VXFILL_MODE::VXFILL_POINT, { u8"VXFILL_POINT" } },
{ LibCmo::VxMath::VXFILL_MODE::VXFILL_WIREFRAME, {"VXFILL_WIREFRAME"} }, { LibCmo::VxMath::VXFILL_MODE::VXFILL_WIREFRAME, { u8"VXFILL_WIREFRAME" } },
{ LibCmo::VxMath::VXFILL_MODE::VXFILL_SOLID, {"VXFILL_SOLID"} }, { LibCmo::VxMath::VXFILL_MODE::VXFILL_SOLID, { u8"VXFILL_SOLID" } },
{ LibCmo::VxMath::VXFILL_MODE::VXFILL_MASK, {"VXFILL_MASK"} }, { LibCmo::VxMath::VXFILL_MODE::VXFILL_MASK, { u8"VXFILL_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXSHADE_MODE> VXSHADE_MODE { const GeneralReflectionArray<LibCmo::VxMath::VXSHADE_MODE> VXSHADE_MODE {
{ LibCmo::VxMath::VXSHADE_MODE::VXSHADE_FLAT, {"VXSHADE_FLAT"} }, { LibCmo::VxMath::VXSHADE_MODE::VXSHADE_FLAT, { u8"VXSHADE_FLAT" } },
{ LibCmo::VxMath::VXSHADE_MODE::VXSHADE_GOURAUD, {"VXSHADE_GOURAUD"} }, { LibCmo::VxMath::VXSHADE_MODE::VXSHADE_GOURAUD, { u8"VXSHADE_GOURAUD" } },
{ LibCmo::VxMath::VXSHADE_MODE::VXSHADE_PHONG, {"VXSHADE_PHONG"} }, { LibCmo::VxMath::VXSHADE_MODE::VXSHADE_PHONG, { u8"VXSHADE_PHONG" } },
{ LibCmo::VxMath::VXSHADE_MODE::VXSHADE_MASK, {"VXSHADE_MASK"} }, { LibCmo::VxMath::VXSHADE_MODE::VXSHADE_MASK, { u8"VXSHADE_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXCMPFUNC> VXCMPFUNC { const GeneralReflectionArray<LibCmo::VxMath::VXCMPFUNC> VXCMPFUNC {
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_NEVER, {"VXCMP_NEVER"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_NEVER, { u8"VXCMP_NEVER" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_LESS, {"VXCMP_LESS"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_LESS, { u8"VXCMP_LESS" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_EQUAL, {"VXCMP_EQUAL"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_EQUAL, { u8"VXCMP_EQUAL" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_LESSEQUAL, {"VXCMP_LESSEQUAL"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_LESSEQUAL, { u8"VXCMP_LESSEQUAL" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_GREATER, {"VXCMP_GREATER"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_GREATER, { u8"VXCMP_GREATER" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_NOTEQUAL, {"VXCMP_NOTEQUAL"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_NOTEQUAL, { u8"VXCMP_NOTEQUAL" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_GREATEREQUAL, {"VXCMP_GREATEREQUAL"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_GREATEREQUAL, { u8"VXCMP_GREATEREQUAL" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_ALWAYS, {"VXCMP_ALWAYS"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_ALWAYS, { u8"VXCMP_ALWAYS" } },
{ LibCmo::VxMath::VXCMPFUNC::VXCMP_MASK, {"VXCMP_MASK"} }, { LibCmo::VxMath::VXCMPFUNC::VXCMP_MASK, { u8"VXCMP_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VX_EFFECT> VX_EFFECT { const GeneralReflectionArray<LibCmo::VxMath::VX_EFFECT> VX_EFFECT {
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_NONE, {"VXEFFECT_NONE"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_NONE, { u8"VXEFFECT_NONE" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_TEXGEN, {"VXEFFECT_TEXGEN"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_TEXGEN, { u8"VXEFFECT_TEXGEN" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_TEXGENREF, {"VXEFFECT_TEXGENREF"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_TEXGENREF, { u8"VXEFFECT_TEXGENREF" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_BUMPENV, {"VXEFFECT_BUMPENV"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_BUMPENV, { u8"VXEFFECT_BUMPENV" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_DP3, {"VXEFFECT_DP3"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_DP3, { u8"VXEFFECT_DP3" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_2TEXTURES, {"VXEFFECT_2TEXTURES"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_2TEXTURES, { u8"VXEFFECT_2TEXTURES" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_3TEXTURES, {"VXEFFECT_3TEXTURES"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_3TEXTURES, { u8"VXEFFECT_3TEXTURES" } },
{ LibCmo::VxMath::VX_EFFECT::VXEFFECT_MASK, {"VXEFFECT_MASK"} }, { LibCmo::VxMath::VX_EFFECT::VXEFFECT_MASK, { u8"VXEFFECT_MASK" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VX_MOVEABLE_FLAGS> VX_MOVEABLE_FLAGS { const GeneralReflectionArray<LibCmo::VxMath::VX_MOVEABLE_FLAGS> VX_MOVEABLE_FLAGS {
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_PICKABLE, {"VX_MOVEABLE_PICKABLE"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_PICKABLE, { u8"VX_MOVEABLE_PICKABLE" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_VISIBLE, {"VX_MOVEABLE_VISIBLE"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_VISIBLE, { u8"VX_MOVEABLE_VISIBLE" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_UPTODATE, {"VX_MOVEABLE_UPTODATE"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_UPTODATE, { u8"VX_MOVEABLE_UPTODATE" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RENDERCHANNELS, {"VX_MOVEABLE_RENDERCHANNELS"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RENDERCHANNELS, { u8"VX_MOVEABLE_RENDERCHANNELS" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_USERBOX, {"VX_MOVEABLE_USERBOX"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_USERBOX, { u8"VX_MOVEABLE_USERBOX" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_EXTENTSUPTODATE, {"VX_MOVEABLE_EXTENTSUPTODATE"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_EXTENTSUPTODATE, { u8"VX_MOVEABLE_EXTENTSUPTODATE" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_BOXVALID, {"VX_MOVEABLE_BOXVALID"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_BOXVALID, { u8"VX_MOVEABLE_BOXVALID" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RENDERLAST, {"VX_MOVEABLE_RENDERLAST"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RENDERLAST, { u8"VX_MOVEABLE_RENDERLAST" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_HASMOVED, {"VX_MOVEABLE_HASMOVED"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_HASMOVED, { u8"VX_MOVEABLE_HASMOVED" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_WORLDALIGNED, {"VX_MOVEABLE_WORLDALIGNED"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_WORLDALIGNED, { u8"VX_MOVEABLE_WORLDALIGNED" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_NOZBUFFERWRITE, {"VX_MOVEABLE_NOZBUFFERWRITE"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_NOZBUFFERWRITE, { u8"VX_MOVEABLE_NOZBUFFERWRITE" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RENDERFIRST, {"VX_MOVEABLE_RENDERFIRST"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RENDERFIRST, { u8"VX_MOVEABLE_RENDERFIRST" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_NOZBUFFERTEST, {"VX_MOVEABLE_NOZBUFFERTEST"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_NOZBUFFERTEST, { u8"VX_MOVEABLE_NOZBUFFERTEST" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_INVERSEWORLDMATVALID, {"VX_MOVEABLE_INVERSEWORLDMATVALID"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_INVERSEWORLDMATVALID, { u8"VX_MOVEABLE_INVERSEWORLDMATVALID" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_DONTUPDATEFROMPARENT, {"VX_MOVEABLE_DONTUPDATEFROMPARENT"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_DONTUPDATEFROMPARENT, { u8"VX_MOVEABLE_DONTUPDATEFROMPARENT" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_INDIRECTMATRIX, {"VX_MOVEABLE_INDIRECTMATRIX"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_INDIRECTMATRIX, { u8"VX_MOVEABLE_INDIRECTMATRIX" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_ZBUFONLY, {"VX_MOVEABLE_ZBUFONLY"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_ZBUFONLY, { u8"VX_MOVEABLE_ZBUFONLY" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_STENCILONLY, {"VX_MOVEABLE_STENCILONLY"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_STENCILONLY, { u8"VX_MOVEABLE_STENCILONLY" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_HIERARCHICALHIDE, {"VX_MOVEABLE_HIERARCHICALHIDE"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_HIERARCHICALHIDE, { u8"VX_MOVEABLE_HIERARCHICALHIDE" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_CHARACTERRENDERED, {"VX_MOVEABLE_CHARACTERRENDERED"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_CHARACTERRENDERED, { u8"VX_MOVEABLE_CHARACTERRENDERED" } },
{ LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RESERVED2, {"VX_MOVEABLE_RESERVED2"} }, { LibCmo::VxMath::VX_MOVEABLE_FLAGS::VX_MOVEABLE_RESERVED2, { u8"VX_MOVEABLE_RESERVED2" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXMESH_FLAGS> VXMESH_FLAGS { const GeneralReflectionArray<LibCmo::VxMath::VXMESH_FLAGS> VXMESH_FLAGS {
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_BOUNDINGUPTODATE, {"VXMESH_BOUNDINGUPTODATE"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_BOUNDINGUPTODATE, { u8"VXMESH_BOUNDINGUPTODATE" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_VISIBLE, {"VXMESH_VISIBLE"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_VISIBLE, { u8"VXMESH_VISIBLE" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_OPTIMIZED, {"VXMESH_OPTIMIZED"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_OPTIMIZED, { u8"VXMESH_OPTIMIZED" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_RENDERCHANNELS, {"VXMESH_RENDERCHANNELS"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_RENDERCHANNELS, { u8"VXMESH_RENDERCHANNELS" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_HASTRANSPARENCY, {"VXMESH_HASTRANSPARENCY"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_HASTRANSPARENCY, { u8"VXMESH_HASTRANSPARENCY" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PRELITMODE, {"VXMESH_PRELITMODE"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PRELITMODE, { u8"VXMESH_PRELITMODE" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_WRAPU, {"VXMESH_WRAPU"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_WRAPU, { u8"VXMESH_WRAPU" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_WRAPV, {"VXMESH_WRAPV"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_WRAPV, { u8"VXMESH_WRAPV" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_FORCETRANSPARENCY, {"VXMESH_FORCETRANSPARENCY"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_FORCETRANSPARENCY, { u8"VXMESH_FORCETRANSPARENCY" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_TRANSPARENCYUPTODATE, {"VXMESH_TRANSPARENCYUPTODATE"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_TRANSPARENCYUPTODATE, { u8"VXMESH_TRANSPARENCYUPTODATE" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_UV_CHANGED, {"VXMESH_UV_CHANGED"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_UV_CHANGED, { u8"VXMESH_UV_CHANGED" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_NORMAL_CHANGED, {"VXMESH_NORMAL_CHANGED"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_NORMAL_CHANGED, { u8"VXMESH_NORMAL_CHANGED" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_COLOR_CHANGED, {"VXMESH_COLOR_CHANGED"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_COLOR_CHANGED, { u8"VXMESH_COLOR_CHANGED" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_POS_CHANGED, {"VXMESH_POS_CHANGED"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_POS_CHANGED, { u8"VXMESH_POS_CHANGED" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_HINTDYNAMIC, {"VXMESH_HINTDYNAMIC"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_HINTDYNAMIC, { u8"VXMESH_HINTDYNAMIC" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_GENNORMALS, {"VXMESH_GENNORMALS"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_GENNORMALS, { u8"VXMESH_GENNORMALS" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PROCEDURALUV, {"VXMESH_PROCEDURALUV"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PROCEDURALUV, { u8"VXMESH_PROCEDURALUV" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PROCEDURALPOS, {"VXMESH_PROCEDURALPOS"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PROCEDURALPOS, { u8"VXMESH_PROCEDURALPOS" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_STRIPIFY, {"VXMESH_STRIPIFY"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_STRIPIFY, { u8"VXMESH_STRIPIFY" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_MONOMATERIAL, {"VXMESH_MONOMATERIAL"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_MONOMATERIAL, { u8"VXMESH_MONOMATERIAL" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PM_BUILDNORM, {"VXMESH_PM_BUILDNORM"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_PM_BUILDNORM, { u8"VXMESH_PM_BUILDNORM" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_BWEIGHTS_CHANGED, {"VXMESH_BWEIGHTS_CHANGED"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_BWEIGHTS_CHANGED, { u8"VXMESH_BWEIGHTS_CHANGED" } },
{ LibCmo::VxMath::VXMESH_FLAGS::VXMESH_ALLFLAGS, {"VXMESH_ALLFLAGS"} }, { LibCmo::VxMath::VXMESH_FLAGS::VXMESH_ALLFLAGS, { u8"VXMESH_ALLFLAGS" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXMESH_LITMODE> VXMESH_LITMODE { const GeneralReflectionArray<LibCmo::VxMath::VXMESH_LITMODE> VXMESH_LITMODE {
{ LibCmo::VxMath::VXMESH_LITMODE::VX_PRELITMESH, {"VX_PRELITMESH"} }, { LibCmo::VxMath::VXMESH_LITMODE::VX_PRELITMESH, { u8"VX_PRELITMESH" } },
{ LibCmo::VxMath::VXMESH_LITMODE::VX_LITMESH, {"VX_LITMESH"} }, { LibCmo::VxMath::VXMESH_LITMODE::VX_LITMESH, { u8"VX_LITMESH" } },
};
const GeneralReflectionArray<LibCmo::VxMath::VXCHANNEL_FLAGS> VXCHANNEL_FLAGS {
{ LibCmo::VxMath::VXCHANNEL_FLAGS::VXCHANNEL_ACTIVE, { u8"VXCHANNEL_ACTIVE" } },
{ LibCmo::VxMath::VXCHANNEL_FLAGS::VXCHANNEL_SAMEUV, { u8"VXCHANNEL_SAMEUV" } },
{ LibCmo::VxMath::VXCHANNEL_FLAGS::VXCHANNEL_NOTLIT, { u8"VXCHANNEL_NOTLIT" } },
{ LibCmo::VxMath::VXCHANNEL_FLAGS::VXCHANNEL_MONO, { u8"VXCHANNEL_MONO" } },
{ LibCmo::VxMath::VXCHANNEL_FLAGS::VXCHANNEL_RESERVED1, { u8"VXCHANNEL_RESERVED1" } },
{ LibCmo::VxMath::VXCHANNEL_FLAGS::VXCHANNEL_LAST, { u8"VXCHANNEL_LAST" } },
}; };
const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_WRAPMODE> VXTEXTURE_WRAPMODE { const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_WRAPMODE> VXTEXTURE_WRAPMODE {
{ LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_NONE, {"VXTEXTUREWRAP_NONE"} }, { LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_NONE, { u8"VXTEXTUREWRAP_NONE" } },
{ LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_U, {"VXTEXTUREWRAP_U"} }, { LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_U, { u8"VXTEXTUREWRAP_U" } },
{ LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_V, {"VXTEXTUREWRAP_V"} }, { LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_V, { u8"VXTEXTUREWRAP_V" } },
{ LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_UV, {"VXTEXTUREWRAP_UV"} }, { LibCmo::VxMath::VXTEXTURE_WRAPMODE::VXTEXTUREWRAP_UV, { u8"VXTEXTUREWRAP_UV" } },
}; };
} }

62
Unvirt/AccessibleValue.hpp
View File

@ -1,41 +1,59 @@
#pragma once #pragma once
#include <VTAll.hpp> #include <VTAll.hpp>
#include "StringHelper.hpp"
#include <vector> #include <vector>
#include <string> #include <string>
#include <type_traits>
namespace Unvirt { namespace Unvirt {
namespace AccessibleValue { namespace AccessibleValue {
constexpr const char c_InvalidEnumName[] = "[undefined]"; constexpr const char8_t c_InvalidEnumName[] = u8"[undefined]";
struct GeneralReflection { const char* mName; }; #pragma region Size Formatter
template<typename _Ty>
std::u8string GetReadableFileSize(uint64_t _size);
#pragma endregion
#pragma region CKERROR CK_CLASSID Data
std::u8string GetCkErrorName(LibCmo::CK2::CKERROR err);
std::u8string GetCkErrorDescription(LibCmo::CK2::CKERROR err);
std::u8string GetClassIdName(LibCmo::CK2::CK_CLASSID cls);
std::u8string GetClassIdHierarchy(LibCmo::CK2::CK_CLASSID cls);
#pragma endregion
#pragma region Other Enums
struct GeneralReflection { const char8_t* mName; };
template<typename _Ty, std::enable_if_t<std::is_enum_v<_Ty>, int> = 0>
using GeneralReflectionArray = std::vector<std::pair<_Ty, GeneralReflection>>; using GeneralReflectionArray = std::vector<std::pair<_Ty, GeneralReflection>>;
template<typename _Ty> template<typename _Ty, std::enable_if_t<std::is_enum_v<_Ty>, int> = 0>
std::string GetEnumName(_Ty val, const GeneralReflectionArray<_Ty>& desc) { std::u8string GetEnumName(_Ty val, const GeneralReflectionArray<_Ty>& desc) {
std::string strl; std::u8string strl;
for (auto& item : desc) { for (auto& item : desc) {
if (item.first == val) { if (item.first == val) {
strl = item.second.mName; strl = item.second.mName;
return strl; return strl;
} }
} }
StringHelper::StdstringPrintf(strl, "%s (0x%08" PRIXCKDWORD ")", YYCC::StringHelper::Printf(strl, u8"%s (0x%08" PRIXCKDWORD ")",
c_InvalidEnumName, c_InvalidEnumName,
static_cast<LibCmo::CKDWORD>(val) static_cast<LibCmo::CKDWORD>(val)
); );
return strl; return strl;
} }
template<typename _Ty> template<typename _Ty, std::enable_if_t<std::is_enum_v<_Ty>, int> = 0>
std::string GetFlagEnumName(_Ty val, const GeneralReflectionArray<_Ty>& desc, const char* splitor) { std::u8string GetFlagEnumName(_Ty val, const GeneralReflectionArray<_Ty>& desc, const char8_t* splitor = u8" ", const char8_t* indent = u8"") {
std::string strl, cache; std::u8string strl, cache;
for (auto& item : desc) { for (auto& item : desc) {
// if it have exacelt same entry, return directly // if it have exacelt same entry, return directly
if (item.first == val) { if (item.first == val) {
StringHelper::StdstringPrintf(strl, "%s (0x%08" PRIXCKDWORD ")", YYCC::StringHelper::Printf(strl, u8"%s (0x%08" PRIXCKDWORD ")",
item.second.mName, item.second.mName,
static_cast<LibCmo::CKDWORD>(item.first) static_cast<LibCmo::CKDWORD>(item.first)
); );
@ -44,11 +62,18 @@ namespace Unvirt {
// check flag match // check flag match
if (LibCmo::EnumsHelper::Has(val, item.first)) { if (LibCmo::EnumsHelper::Has(val, item.first)) {
// add splittor if it not the first entry
if (strl.size() != 0u && splitor != nullptr) { if (strl.size() != 0u && splitor != nullptr) {
strl += splitor; strl += splitor;
} }
StringHelper::StdstringPrintf(cache, "%s (0x%08" PRIXCKDWORD ")", // add indent if possible
if (indent != nullptr) {
strl += indent;
}
// add value self.
YYCC::StringHelper::Printf(cache, u8"%s (0x%08" PRIXCKDWORD ")",
item.second.mName, item.second.mName,
static_cast<LibCmo::CKDWORD>(item.first) static_cast<LibCmo::CKDWORD>(item.first)
); );
@ -58,7 +83,7 @@ namespace Unvirt {
// if nothing was gotten. set to undefined // if nothing was gotten. set to undefined
if (strl.size() == 0u) { if (strl.size() == 0u) {
StringHelper::StdstringPrintf(strl, "%s (0x%08" PRIXCKDWORD ")", YYCC::StringHelper::Printf(strl, u8"%s (0x%08" PRIXCKDWORD ")",
c_InvalidEnumName, c_InvalidEnumName,
static_cast<LibCmo::CKDWORD>(val) static_cast<LibCmo::CKDWORD>(val)
); );
@ -67,13 +92,6 @@ namespace Unvirt {
return strl; return strl;
} }
std::string GetClassIdName(LibCmo::CK2::CK_CLASSID cls);
std::string GetCkErrorName(LibCmo::CK2::CKERROR err);
std::string GetClassIdHierarchy(LibCmo::CK2::CK_CLASSID cls);
std::string GetCkErrorDescription(LibCmo::CK2::CKERROR err);
std::string GetReadableFileSize(uint64_t size);
namespace EnumDesc { namespace EnumDesc {
extern const GeneralReflectionArray<LibCmo::CK2::CK_FILE_WRITEMODE> CK_FILE_WRITEMODE; extern const GeneralReflectionArray<LibCmo::CK2::CK_FILE_WRITEMODE> CK_FILE_WRITEMODE;
extern const GeneralReflectionArray<LibCmo::CK2::CK_FO_OPTIONS> CK_FO_OPTIONS; extern const GeneralReflectionArray<LibCmo::CK2::CK_FO_OPTIONS> CK_FO_OPTIONS;
@ -100,5 +118,7 @@ namespace Unvirt {
extern const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_WRAPMODE> VXTEXTURE_WRAPMODE; extern const GeneralReflectionArray<LibCmo::VxMath::VXTEXTURE_WRAPMODE> VXTEXTURE_WRAPMODE;
} }
#pragma endregion
} }
} }

2
Unvirt/CMakeLists.txt
View File

@ -5,7 +5,6 @@ target_sources(Unvirt
PRIVATE PRIVATE
AccessibleValue.cpp AccessibleValue.cpp
CmdHelper.cpp CmdHelper.cpp
StringHelper.cpp
StructFormatter.cpp StructFormatter.cpp
TerminalHelper.cpp TerminalHelper.cpp
UnvirtContext.cpp UnvirtContext.cpp
@ -18,7 +17,6 @@ FILE_SET HEADERS
FILES FILES
AccessibleValue.hpp AccessibleValue.hpp
CmdHelper.hpp CmdHelper.hpp
StringHelper.hpp
StructFormatter.hpp StructFormatter.hpp
TerminalHelper.hpp TerminalHelper.hpp
UnvirtContext.hpp UnvirtContext.hpp

30
Unvirt/StringHelper.cpp
View File

@ -1,30 +0,0 @@
#include "StringHelper.hpp"
#include <stdexcept>
namespace Unvirt::StringHelper {
void StdstringPrintf(std::string& strl, const char* format, ...) {
va_list argptr;
va_start(argptr, format);
StdstringVPrintf(strl, format, argptr);
va_end(argptr);
}
void StdstringVPrintf(std::string& strl, const char* format, va_list argptr) {
va_list args1;
va_copy(args1, argptr);
va_list args2;
va_copy(args2, argptr);
int count = std::vsnprintf(nullptr, 0, format, args1);
if (count < 0) throw new std::length_error("Invalid length returned by vsnprintf.");
va_end(args1);
strl.resize(count);
int write_result = std::vsnprintf(strl.data(), strl.size() + 1, format, args2);
va_end(args2);
if (write_result < 0 || write_result > count) throw new std::length_error("Invalid write result in vsnprintf.");
}
}

11
Unvirt/StringHelper.hpp
View File

@ -1,11 +0,0 @@
#pragma once
#include <string>
#include <cstdarg>
namespace Unvirt::StringHelper {
void StdstringPrintf(std::string& strl, const char* format, ...);
void StdstringVPrintf(std::string& strl, const char* format, va_list argptr);
}

550
Unvirt/StructFormatter.cpp
View File

@ -1,59 +1,65 @@
#include "StructFormatter.hpp" #include "StructFormatter.hpp"
#include <YYCCommonplace.hpp>
#include "AccessibleValue.hpp" #include "AccessibleValue.hpp"
#include "TerminalHelper.hpp" #include "TerminalHelper.hpp"
namespace Console = YYCC::ConsoleHelper;
namespace Unvirt::StructFormatter { namespace Unvirt::StructFormatter {
#pragma region Assist Functions #pragma region Assist Functions
static void PrintCKSTRING(LibCmo::CKSTRING name) { static std::u8string PrintCKSTRING(LibCmo::CKSTRING name) {
std::u8string ret;
if (name == nullptr) { if (name == nullptr) {
fputs(UNVIRT_TERMCOL_LIGHT_MAGENTA(("<anonymous>")), stdout); ret = YYCC_COLOR_LIGHT_MAGENTA(u8"<anonymous>");
} else { } else {
if (name[0] == '\0') { if (name[0] == u8'\0') {
fputs(UNVIRT_TERMCOL_LIGHT_MAGENTA(("<blank>")), stdout); ret = YYCC_COLOR_LIGHT_MAGENTA(u8"<blank>");
} else { } else {
fputs(name, stdout); ret = name;
} }
} }
return ret;
} }
static void PrintPointer(const void* ptr) { static std::u8string PrintPointer(const void* ptr) {
std::u8string ret;
if (ptr == nullptr) { if (ptr == nullptr) {
fputs(UNVIRT_TERMCOL_LIGHT_CYAN(("<null>")), stdout); ret = YYCC_COLOR_LIGHT_CYAN(u8"<null>");
} else { } else {
#if UINTPTR_MAX == UINT32_MAX YYCC::StringHelper::Printf(ret, u8"<0x%" PRI_XPTR_LEFT_PADDING PRIxPTR ">", reinterpret_cast<uintptr_t>(ptr));
// 32 bit. padding 8 zero
fprintf(stdout, "<0x%08" PRIxPTR ">", reinterpret_cast<uintptr_t>(ptr));
#else
// 64 bit. padding 16 zero
fprintf(stdout, "<0x%016" PRIxPTR ">", reinterpret_cast<uintptr_t>(ptr));
#endif
} }
return ret;
} }
static void PrintCKGUID(const LibCmo::CK2::CKGUID& guid) { static std::u8string PrintCKGUID(const LibCmo::CK2::CKGUID& guid) {
fprintf(stdout, "<0x%08" PRIxCKDWORD ", 0x%08" PRIxCKDWORD ">", guid.d1, guid.d2); return YYCC::StringHelper::Printf(u8"<0x%08" PRIxCKDWORD ", 0x%08" PRIxCKDWORD ">", guid.d1, guid.d2);
} }
static void PrintBool(bool v) { static std::u8string PrintBool(bool v) {
fputs(v ? "true" : "false", stdout); return (v ? u8"true" : u8"false");
} }
static void PrintColorfulBool(bool v) { static std::u8string PrintColorfulBool(bool v) {
fputs(v ? UNVIRT_TERMCOL_LIGHT_GREEN(("Yes")) : UNVIRT_TERMCOL_LIGHT_RED(("No")), stdout); return (v ? YYCC_COLOR_LIGHT_GREEN(u8"Yes") : YYCC_COLOR_LIGHT_RED(u8"No"));
} }
static void PrintColor(const LibCmo::VxMath::VxColor& col) { static std::u8string PrintColor(LibCmo::CKDWORD argb) {
LibCmo::CKDWORD argb = col.ToARGB();
LibCmo::CKDWORD a = (argb & 0xFF000000) >> 24, LibCmo::CKDWORD a = (argb & 0xFF000000) >> 24,
r = (argb & 0x00FF0000) >> 16, r = (argb & 0x00FF0000) >> 16,
g = (argb & 0x0000FF00) >> 8, g = (argb & 0x0000FF00) >> 8,
b = (argb & 0x000000FF); b = (argb & 0x000000FF);
fprintf(stdout, "A:%" PRIuCKDWORD " (%.4" PRIfCKFLOAT ") RGB(%" PRIuCKDWORD ", %" PRIuCKDWORD ", %" PRIuCKDWORD ") RGB#%02" PRIxCKDWORD "%02" PRIxCKDWORD "%02" PRIxCKDWORD " RGBA#%02" PRIxCKDWORD "%02" PRIxCKDWORD "%02" PRIxCKDWORD "%02" PRIxCKDWORD, LibCmo::CKFLOAT fa = static_cast<LibCmo::CKFLOAT>(a) / 255.0f;
a, col.a, return YYCC::StringHelper::Printf(
u8"A:%" PRIuCKDWORD " (%.4" PRIfCKFLOAT ") "
"RGB(%" PRIuCKDWORD ", %" PRIuCKDWORD ", %" PRIuCKDWORD ") "
"RGB#%02" PRIxCKDWORD "%02" PRIxCKDWORD "%02" PRIxCKDWORD " "
"RGBA#%02" PRIxCKDWORD "%02" PRIxCKDWORD "%02" PRIxCKDWORD "%02" PRIxCKDWORD,
a, fa,
r, g, b, r, g, b,
r, g, b, r, g, b,
r, g, b, a r, g, b, a
); );
} }
static void PrintColor(LibCmo::CKDWORD argb) { static std::u8string PrintColor(const LibCmo::VxMath::VxColor& col) {
PrintColor(LibCmo::VxMath::VxColor(argb)); return PrintColor(col.ToARGB());
} }
template<class _Ty> template<class _Ty>
@ -63,7 +69,7 @@ namespace Unvirt::StructFormatter {
// check page overflow // check page overflow
if (page * pageitems >= data.size()) { if (page * pageitems >= data.size()) {
fputs(UNVIRT_TERMCOL_LIGHT_RED(("Page out of range.\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"Page out of range."));
return; return;
} }
@ -80,7 +86,7 @@ namespace Unvirt::StructFormatter {
printEntryFct(counter, data[counter]); printEntryFct(counter, data[counter]);
} }
fprintf(stdout, "Page %" PRIuSIZET " of %" PRIuSIZET "\n", page + 1, fullpage); Console::FormatLine(u8"Page %" PRIuSIZET " of %" PRIuSIZET, page + 1, fullpage);
} }
#pragma endregion #pragma endregion
@ -88,281 +94,281 @@ namespace Unvirt::StructFormatter {
#pragma region Object Printer #pragma region Object Printer
static void PrintCKObjectDetail(LibCmo::CK2::ObjImpls::CKObject* obj) { static void PrintCKObjectDetail(LibCmo::CK2::ObjImpls::CKObject* obj) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKObject\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKObject"));
// print name // print name
fputs("Name: ", stdout); Console::FormatLine(u8"Name: %s", PrintCKSTRING(obj->GetName()).c_str());
PrintCKSTRING(obj->GetName());
fputc('\n', stdout);
// print id // print id
fprintf(stdout, "CK ID: %" PRIuCKID "\n", obj->GetID()); Console::FormatLine(u8"CK ID: %" PRIuCKID, obj->GetID());
// print class id // print class id
fprintf(stdout, "Class ID: %" PRIiCLASSID " (%s)\n", obj->GetClassID(), AccessibleValue::GetClassIdHierarchy(obj->GetClassID()).c_str()); Console::FormatLine(u8"Class ID: %" PRIiCLASSID " (%s)", obj->GetClassID(), AccessibleValue::GetClassIdHierarchy(obj->GetClassID()).c_str());
// print flags // print flags
fputs("Flags:\n", stdout); Console::WriteLine(u8"Flags:");
fputs(AccessibleValue::GetFlagEnumName(obj->GetObjectFlags(), AccessibleValue::EnumDesc::CK_OBJECT_FLAGS, "\n").c_str(), stdout); Console::WriteLine(AccessibleValue::GetFlagEnumName(obj->GetObjectFlags(), AccessibleValue::EnumDesc::CK_OBJECT_FLAGS, u8"\n", u8"\t").c_str());
fputc('\n', stdout);
} }
static void PrintCKSceneObjectDetail(LibCmo::CK2::ObjImpls::CKSceneObject* obj) { static void PrintCKSceneObjectDetail(LibCmo::CK2::ObjImpls::CKSceneObject* obj) {
PrintCKObjectDetail(obj); PrintCKObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKSceneObject\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKSceneObject"));
fputs(UNVIRT_TERMCOL_LIGHT_RED(("No Data\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"No Data"));
} }
static void PrintCKBeObjectDetail(LibCmo::CK2::ObjImpls::CKBeObject* obj) { static void PrintCKBeObjectDetail(LibCmo::CK2::ObjImpls::CKBeObject* obj) {
PrintCKSceneObjectDetail(obj); PrintCKSceneObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKBeObject\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKBeObject"));
fputs(UNVIRT_TERMCOL_LIGHT_RED(("No Data\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"No Data"));
} }
static void PrintCKGroupDetail(LibCmo::CK2::ObjImpls::CKGroup* obj) { static void PrintCKGroupDetail(LibCmo::CK2::ObjImpls::CKGroup* obj) {
PrintCKBeObjectDetail(obj); PrintCKBeObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKGroup\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKGroup"));
LibCmo::CKDWORD count = obj->GetObjectCount(); LibCmo::CKDWORD count = obj->GetObjectCount();
fprintf(stdout, "Group Object Count: %" PRIuCKDWORD "\n", count); Console::FormatLine(u8"Group Object Count: %" PRIuCKDWORD, count);
fputs("CKID\tType\tObject\tName\n", stdout); Console::WriteLine(u8"CKID\tType\tObject\tName");
for (LibCmo::CKDWORD i = 0; i < count; ++i) { for (LibCmo::CKDWORD i = 0; i < count; ++i) {
LibCmo::CK2::ObjImpls::CKBeObject* beobj = obj->GetObject(i); LibCmo::CK2::ObjImpls::CKBeObject* beobj = obj->GetObject(i);
fprintf(stdout, "%" PRIuCKID "\t", beobj->GetID()); Console::FormatLine(u8"%" PRIuCKID "\t%s\t%s\t%s",
fputs(AccessibleValue::GetClassIdName(beobj->GetClassID()).c_str(), stdout); beobj->GetID(),
fputc('\t', stdout); AccessibleValue::GetClassIdName(beobj->GetClassID()).c_str(),
PrintPointer(beobj); PrintPointer(beobj).c_str(),
fputc('\t', stdout); PrintCKSTRING(beobj->GetName()).c_str()
PrintCKSTRING(beobj->GetName()); );
fputc('\n', stdout);
} }
} }
static void PrintCKRenderObjectDetail(LibCmo::CK2::ObjImpls::CKRenderObject* obj) { static void PrintCKRenderObjectDetail(LibCmo::CK2::ObjImpls::CKRenderObject* obj) {
PrintCKBeObjectDetail(obj); PrintCKBeObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKRenderObject\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKRenderObject"));
fputs(UNVIRT_TERMCOL_LIGHT_RED(("No Data\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"No Data"));
} }
static void PrintCK3dEntityDetail(LibCmo::CK2::ObjImpls::CK3dEntity* obj) { static void PrintCK3dEntityDetail(LibCmo::CK2::ObjImpls::CK3dEntity* obj) {
PrintCKRenderObjectDetail(obj); PrintCKRenderObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CK3dEntity\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CK3dEntity"));
fputs("== World Matrix ==\n", stdout); Console::WriteLine(u8"== World Matrix ==");
auto mat = obj->GetWorldMatrix(); auto mat = obj->GetWorldMatrix();
for (LibCmo::CKDWORD i = 0; i < 4; ++i) { for (LibCmo::CKDWORD i = 0; i < 4; ++i) {
fprintf(stdout, "%+" PRIeCKFLOAT "\t%+" PRIeCKFLOAT "\t%+" PRIeCKFLOAT "\t%+" PRIeCKFLOAT "\n", Console::FormatLine(u8"%+" PRIeCKFLOAT "\t%+" PRIeCKFLOAT "\t%+" PRIeCKFLOAT "\t%+" PRIeCKFLOAT,
mat[i].x, mat[i].y, mat[i].z, mat[i].w mat[i].x, mat[i].y, mat[i].z, mat[i].w
); );
} }
fputs("== Flags ==\n", stdout); Console::WriteLine(u8"== Flags ==");
fputs("3dEntity Flags:\n", stdout); Console::WriteLine(u8"3dEntity Flags:");
fputs(AccessibleValue::GetFlagEnumName(obj->GetEntityFlags(), AccessibleValue::EnumDesc::CK_3DENTITY_FLAGS, "\n").c_str(), stdout); Console::WriteLine(AccessibleValue::GetFlagEnumName(obj->GetEntityFlags(), AccessibleValue::EnumDesc::CK_3DENTITY_FLAGS, u8"\n", u8"\t").c_str());
fputc('\n', stdout); Console::WriteLine(u8"Moveable Flags:");
fputs("Moveable Flags:\n", stdout); Console::WriteLine(AccessibleValue::GetFlagEnumName(obj->GetMoveableFlags(), AccessibleValue::EnumDesc::VX_MOVEABLE_FLAGS, u8"\n", u8"\t").c_str());
fputs(AccessibleValue::GetFlagEnumName(obj->GetMoveableFlags(), AccessibleValue::EnumDesc::VX_MOVEABLE_FLAGS, "\n").c_str(), stdout);
fputc('\n', stdout);
fputs("== Meshs ==\n", stdout); Console::WriteLine(u8"== Meshs ==");
fputs("Index\tAddress\tName\n", stdout); Console::WriteLine(u8"Index\tAddress\tName");
// print current mesh // print current mesh
auto curmesh = obj->GetCurrentMesh(); {
fputs("->\t", stdout); auto curmesh = obj->GetCurrentMesh();
PrintPointer(curmesh); Console::Format(u8"->\t%s",
fputc('\t', stdout); PrintPointer(curmesh).c_str()
if (curmesh != nullptr) );
PrintCKSTRING(curmesh->GetName()); if (curmesh != nullptr) {
fputc('\n', stdout); Console::FormatLine(u8"\t%s",
PrintCKSTRING(curmesh->GetName()).c_str()
);
} else {
Console::WriteLine(u8"");
}
}
// print other meshes
for (LibCmo::CKDWORD i = 0; i < obj->GetPotentialMeshCount(); ++i) { for (LibCmo::CKDWORD i = 0; i < obj->GetPotentialMeshCount(); ++i) {
auto thismesh = obj->GetPotentialMesh(i); auto thismesh = obj->GetPotentialMesh(i);
fprintf(stdout, "#%" PRIuCKDWORD "\t", i); Console::FormatLine(u8"#%" PRIuCKDWORD "\t%s\t%s",
PrintPointer(thismesh); i,
fputc('\t', stdout); PrintPointer(thismesh).c_str(),
PrintCKSTRING(thismesh->GetName()); PrintCKSTRING(thismesh->GetName()).c_str()
fputc('\n', stdout); );
} }
} }
static void PrintCK3dObjectDetail(LibCmo::CK2::ObjImpls::CK3dObject* obj) { static void PrintCK3dObjectDetail(LibCmo::CK2::ObjImpls::CK3dObject* obj) {
PrintCK3dEntityDetail(obj); PrintCK3dEntityDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CK3dObject\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CK3dObject"));
fputs(UNVIRT_TERMCOL_LIGHT_RED(("No Data\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"No Data"));
} }
static void PrintCKTextureDetail(LibCmo::CK2::ObjImpls::CKTexture* obj) { static void PrintCKTextureDetail(LibCmo::CK2::ObjImpls::CKTexture* obj) {
PrintCKBeObjectDetail(obj); PrintCKBeObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKTexture\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKTexture"));
// texture // texture
fputs("== Texture ==\n", stdout); Console::WriteLine(u8"== Texture ==");
LibCmo::CK2::CKBitmapData& bd = obj->GetUnderlyingData(); LibCmo::CK2::CKBitmapData& bd = obj->GetUnderlyingData();
LibCmo::CKDWORD slot_count = bd.GetSlotCount(); LibCmo::CKDWORD slot_count = bd.GetSlotCount();
fprintf(stdout, "Slot Count: %" PRIuCKDWORD "\n", slot_count); Console::FormatLine(u8"Slot Count: %" PRIuCKDWORD, slot_count);
fprintf(stdout, "Current Slot: %" PRIuCKDWORD "\n", bd.GetCurrentSlot()); Console::FormatLine(u8"Current Slot: %" PRIuCKDWORD, bd.GetCurrentSlot());
fputs("Index\tWidth\tHeight\tImage Addr\tImage Size\tFilename\n", stdout); Console::WriteLine(u8"Index\tWidth\tHeight\tImage Addr\tImage Size\tFilename");
for (LibCmo::CKDWORD i = 0; i < slot_count; ++i) { for (LibCmo::CKDWORD i = 0; i < slot_count; ++i) {
auto desc = bd.GetImageDesc(i); auto desc = bd.GetImageDesc(i);
fprintf(stdout, "#%" PRIuCKDWORD "\t", i); Console::FormatLine(u8"#%" PRIuCKDWORD "\t%" PRIuCKDWORD "\t%" PRIuCKDWORD "\t0x%" PRIxCKDWORD " bytes\t",
fprintf(stdout, "%" PRIuCKDWORD "\t%" PRIuCKDWORD "\t", desc->GetWidth(), desc->GetHeight()); i,
PrintPointer(desc->GetImage()); desc->GetWidth(),
fputc('\t', stdout); desc->GetHeight(),
fprintf(stdout, "0x%" PRIxCKDWORD " bytes\t", desc->GetImageSize()); PrintPointer(desc->GetImage()).c_str(),
PrintCKSTRING(bd.GetSlotFileName(i)); desc->GetImageSize(),
fputc('\n', stdout); PrintCKSTRING(bd.GetSlotFileName(i)).c_str()
);
} }
// other data // other data
fputs("== Misc ==\n", stdout); Console::WriteLine(u8"== Misc ==");
fprintf(stdout, "Video Format: %s\n", AccessibleValue::GetEnumName(obj->GetVideoFormat(), AccessibleValue::EnumDesc::VX_PIXELFORMAT).c_str()); Console::FormatLine(u8"Video Format: %s", AccessibleValue::GetEnumName(obj->GetVideoFormat(), AccessibleValue::EnumDesc::VX_PIXELFORMAT).c_str());
fprintf(stdout, "Save Option: %s\n", AccessibleValue::GetEnumName(bd.GetSaveOptions(), AccessibleValue::EnumDesc::CK_TEXTURE_SAVEOPTIONS).c_str()); Console::FormatLine(u8"Save Option: %s", AccessibleValue::GetEnumName(bd.GetSaveOptions(), AccessibleValue::EnumDesc::CK_TEXTURE_SAVEOPTIONS).c_str());
fprintf(stdout, "Pick Threshold: %" PRIuCKDWORD "\n", bd.GetPickThreshold()); Console::FormatLine(u8"Pick Threshold: %" PRIuCKDWORD, bd.GetPickThreshold());
fputs("Transparent Color: ", stdout); Console::FormatLine(u8"Transparent Color: %s", PrintColor(bd.GetTransparentColor()).c_str());
PrintColor(bd.GetTransparentColor());
fputc('\n', stdout);
fputs("Bitmap Flags:\n", stdout); Console::WriteLine(u8"Bitmap Flags:");
fputs(AccessibleValue::GetFlagEnumName(bd.GetBitmapFlags(), AccessibleValue::EnumDesc::CK_BITMAPDATA_FLAGS, "\n").c_str(), stdout); Console::WriteLine(AccessibleValue::GetFlagEnumName(bd.GetBitmapFlags(), AccessibleValue::EnumDesc::CK_BITMAPDATA_FLAGS, u8"\n", u8"\t").c_str());
fputc('\n', stdout);
} }
static void PrintCKMaterialDetail(LibCmo::CK2::ObjImpls::CKMaterial* obj) { static void PrintCKMaterialDetail(LibCmo::CK2::ObjImpls::CKMaterial* obj) {
PrintCKBeObjectDetail(obj); PrintCKBeObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKMaterial\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKMaterial"));
// color // color
fputs("== Color ==\n", stdout); Console::WriteLine(u8"== Color ==");
fputs("Diffuse: ", stdout); Console::Write(u8"Diffuse: ");
PrintColor(obj->GetDiffuse()); PrintColor(obj->GetDiffuse());
fputc('\n', stdout); Console::Write(u8"\n");
fputs("Ambient: ", stdout); Console::Write(u8"Ambient: ");
PrintColor(obj->GetAmbient()); PrintColor(obj->GetAmbient());
fputc('\n', stdout); Console::Write(u8"\n");
fputs("Specular: ", stdout); Console::Write(u8"Specular: ");
PrintColor(obj->GetSpecular()); PrintColor(obj->GetSpecular());
fputc('\n', stdout); Console::Write(u8"\n");
fputs("Emissive: ", stdout); Console::Write(u8"Emissive: ");
PrintColor(obj->GetEmissive()); PrintColor(obj->GetEmissive());
fputc('\n', stdout); Console::Write(u8"\n");
fprintf(stdout, "Specular Power: %.2" PRIfCKFLOAT "\n", obj->GetSpecularPower()); Console::FormatLine(u8"Specular Power: %.2" PRIfCKFLOAT, obj->GetSpecularPower());
// basic data // basic data
fputs("== Basic ==\n", stdout); Console::WriteLine(u8"== Basic ==");
fputs("Both Sided: ", stdout); Console::Write(u8"Both Sided: ");
PrintBool(obj->GetTwoSidedEnabled()); PrintBool(obj->GetTwoSidedEnabled());
fputc('\n', stdout); Console::Write(u8"\n");
fprintf(stdout, "Fill Mode: %s\n", AccessibleValue::GetEnumName(obj->GetFillMode(), AccessibleValue::EnumDesc::VXFILL_MODE).c_str()); Console::FormatLine(u8"Fill Mode: %s", AccessibleValue::GetEnumName(obj->GetFillMode(), AccessibleValue::EnumDesc::VXFILL_MODE).c_str());
fprintf(stdout, "Shade Mode: %s\n", AccessibleValue::GetEnumName(obj->GetShadeMode(), AccessibleValue::EnumDesc::VXSHADE_MODE).c_str()); Console::FormatLine(u8"Shade Mode: %s", AccessibleValue::GetEnumName(obj->GetShadeMode(), AccessibleValue::EnumDesc::VXSHADE_MODE).c_str());
// textures // textures
fputs("== Texture ==\n", stdout); Console::WriteLine(u8"== Texture ==");
fputs("Textures:\n", stdout); Console::WriteLine(u8"Textures:");
fputs("Index\tAddress\tName\n", stdout); Console::WriteLine(u8"Index\tAddress\tName");
for (LibCmo::CKDWORD i = 0; i < 4; ++i) { for (LibCmo::CKDWORD i = 0; i < 4; ++i) {
auto tex = obj->GetTexture(i); auto tex = obj->GetTexture(i);
fprintf(stdout, "#%" PRIuCKDWORD "\t", i); if (tex != nullptr) {
PrintPointer(tex); Console::FormatLine(u8"#%" PRIuCKDWORD "\t%s\t%s",
fputc('\t', stdout); i,
if (tex != nullptr) PrintPointer(tex),
PrintCKSTRING(tex->GetName()); PrintCKSTRING(tex->GetName()).c_str()
fputc('\n', stdout); );
} else {
Console::FormatLine(u8"#%" PRIuCKDWORD "\t%s",
i,
PrintPointer(tex)
);
}
} }
fprintf(stdout, "Texture Blend: %s\n", AccessibleValue::GetEnumName(obj->GetTextureBlendMode(), AccessibleValue::EnumDesc::VXTEXTURE_BLENDMODE).c_str()); Console::FormatLine(u8"Texture Blend: %s", AccessibleValue::GetEnumName(obj->GetTextureBlendMode(), AccessibleValue::EnumDesc::VXTEXTURE_BLENDMODE).c_str());
fprintf(stdout, "Filter Min: %s\n", AccessibleValue::GetEnumName(obj->GetTextureMinMode(), AccessibleValue::EnumDesc::VXTEXTURE_FILTERMODE).c_str()); Console::FormatLine(u8"Filter Min: %s", AccessibleValue::GetEnumName(obj->GetTextureMinMode(), AccessibleValue::EnumDesc::VXTEXTURE_FILTERMODE).c_str());
fprintf(stdout, "Filter Mag: %s\n", AccessibleValue::GetEnumName(obj->GetTextureMagMode(), AccessibleValue::EnumDesc::VXTEXTURE_FILTERMODE).c_str()); Console::FormatLine(u8"Filter Mag: %s", AccessibleValue::GetEnumName(obj->GetTextureMagMode(), AccessibleValue::EnumDesc::VXTEXTURE_FILTERMODE).c_str());
fprintf(stdout, "Address Mode: %s\n", AccessibleValue::GetEnumName(obj->GetTextureAddressMode(), AccessibleValue::EnumDesc::VXTEXTURE_ADDRESSMODE).c_str()); Console::FormatLine(u8"Address Mode: %s", AccessibleValue::GetEnumName(obj->GetTextureAddressMode(), AccessibleValue::EnumDesc::VXTEXTURE_ADDRESSMODE).c_str());
fputs("Perspective Correct: ", stdout); Console::Write(u8"Perspective Correct: ");
PrintBool(obj->GetPerspectiveCorrectionEnabled()); PrintBool(obj->GetPerspectiveCorrectionEnabled());
fputc('\n', stdout); Console::Write(u8"\n");
// alpha test // alpha test
fputs("== Alpha Test ==\n", stdout); Console::WriteLine(u8"== Alpha Test ==");
fputs("Enabled: ", stdout); Console::Write(u8"Enabled: ");
PrintBool(obj->GetAlphaTestEnabled()); PrintBool(obj->GetAlphaTestEnabled());
fputc('\n', stdout); Console::Write(u8"\n");
fprintf(stdout, "Alpha Function: %s\n", AccessibleValue::GetEnumName(obj->GetAlphaFunc(), AccessibleValue::EnumDesc::VXCMPFUNC).c_str()); Console::FormatLine(u8"Alpha Function: %s", AccessibleValue::GetEnumName(obj->GetAlphaFunc(), AccessibleValue::EnumDesc::VXCMPFUNC).c_str());
fprintf(stdout, "Alpha Ref Value: %" PRIuCKBYTE "\n", obj->GetAlphaRef()); Console::FormatLine(u8"Alpha Ref Value: %" PRIuCKBYTE, obj->GetAlphaRef());
// alpha blend // alpha blend
fputs("== Alpha Blend ==\n", stdout); Console::WriteLine(u8"== Alpha Blend ==");
fputs("Enabled: ", stdout); Console::Write(u8"Enabled: ");
PrintBool(obj->GetAlphaBlendEnabled()); PrintBool(obj->GetAlphaBlendEnabled());
fputc('\n', stdout); Console::Write(u8"\n");
fprintf(stdout, "Source Blend: %s\n", AccessibleValue::GetEnumName(obj->GetSourceBlend(), AccessibleValue::EnumDesc::VXBLEND_MODE).c_str()); Console::FormatLine(u8"Source Blend: %s", AccessibleValue::GetEnumName(obj->GetSourceBlend(), AccessibleValue::EnumDesc::VXBLEND_MODE).c_str());
fprintf(stdout, "Destination Blend: %s\n", AccessibleValue::GetEnumName(obj->GetDestBlend(), AccessibleValue::EnumDesc::VXBLEND_MODE).c_str()); Console::FormatLine(u8"Destination Blend: %s", AccessibleValue::GetEnumName(obj->GetDestBlend(), AccessibleValue::EnumDesc::VXBLEND_MODE).c_str());
// z buffer // z buffer
fputs("== Z-Buffer Write ==\n", stdout); Console::WriteLine(u8"== Z-Buffer Write ==");
fputs("Enabled: ", stdout); Console::Write(u8"Enabled: ");
PrintBool(obj->GetZWriteEnabled()); PrintBool(obj->GetZWriteEnabled());
fputc('\n', stdout); Console::Write(u8"\n");
fprintf(stdout, "Z Compare Function: %s\n", AccessibleValue::GetEnumName(obj->GetZFunc(), AccessibleValue::EnumDesc::VXCMPFUNC).c_str()); Console::FormatLine(u8"Z Compare Function: %s", AccessibleValue::GetEnumName(obj->GetZFunc(), AccessibleValue::EnumDesc::VXCMPFUNC).c_str());
// effect // effect
fputs("== Effect ==\n", stdout); Console::WriteLine(u8"== Effect ==");
fprintf(stdout, "Effect: %s\n", AccessibleValue::GetEnumName(obj->GetEffect(), AccessibleValue::EnumDesc::VX_EFFECT).c_str()); Console::FormatLine(u8"Effect: %s", AccessibleValue::GetEnumName(obj->GetEffect(), AccessibleValue::EnumDesc::VX_EFFECT).c_str());
} }
static void PrintCKMeshDetail(LibCmo::CK2::ObjImpls::CKMesh* obj) { static void PrintCKMeshDetail(LibCmo::CK2::ObjImpls::CKMesh* obj) {
PrintCKBeObjectDetail(obj); PrintCKBeObjectDetail(obj);
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKMesh\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKMesh"));
fputs("== Flags ==\n", stdout); Console::WriteLine(u8"== Flags ==");
fputs("Mesh Flags:\n", stdout); Console::WriteLine(u8"Mesh Flags:");
fputs(AccessibleValue::GetFlagEnumName(obj->GetMeshFlags(), AccessibleValue::EnumDesc::VXMESH_FLAGS, "\n").c_str(), stdout); Console::WriteLine(AccessibleValue::GetFlagEnumName(obj->GetMeshFlags(), AccessibleValue::EnumDesc::VXMESH_FLAGS, u8"\n").c_str());
fputc('\n', stdout); Console::FormatLine(u8"Lit Mode: %s", AccessibleValue::GetEnumName(obj->GetLitMode(), AccessibleValue::EnumDesc::VXMESH_LITMODE).c_str());
fputs("Lit Mode: ", stdout); Console::FormatLine(u8"Wrap Mode: %s", AccessibleValue::GetEnumName(obj->GetWrapMode(), AccessibleValue::EnumDesc::VXTEXTURE_WRAPMODE).c_str());
fputs(AccessibleValue::GetEnumName(obj->GetLitMode(), AccessibleValue::EnumDesc::VXMESH_LITMODE).c_str(), stdout);
fputc('\n', stdout);
fputs("Wrap Mode: ", stdout);
fputs(AccessibleValue::GetEnumName(obj->GetWrapMode(), AccessibleValue::EnumDesc::VXTEXTURE_WRAPMODE).c_str(), stdout);
fputc('\n', stdout);
// vertex data // vertex data
fputs("== Vertex ==\n", stdout); Console::WriteLine(u8"== Vertex ==");
fprintf(stdout, "Vertex Count: %" PRIuCKDWORD "\n", obj->GetVertexCount()); Console::FormatLine(u8"Vertex Count: %" PRIuCKDWORD, obj->GetVertexCount());
fputs("Address\tSize\tType\n", stdout); Console::WriteLine(u8"Address\tSize\tType");
PrintPointer(obj->GetVertexPositions()); PrintPointer(obj->GetVertexPositions());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tPositions\n", obj->GetVertexCount() * CKSizeof(LibCmo::VxMath::VxVector3)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tPositions", obj->GetVertexCount() * CKSizeof(LibCmo::VxMath::VxVector3));
PrintPointer(obj->GetVertexNormals()); PrintPointer(obj->GetVertexNormals());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tNormals\n", obj->GetVertexCount() * CKSizeof(LibCmo::VxMath::VxVector3)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tNormals", obj->GetVertexCount() * CKSizeof(LibCmo::VxMath::VxVector3));
PrintPointer(obj->GetVertexUVs()); PrintPointer(obj->GetVertexUVs());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tUVs\n", obj->GetVertexCount() * CKSizeof(LibCmo::VxMath::VxVector2)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tUVs", obj->GetVertexCount() * CKSizeof(LibCmo::VxMath::VxVector2));
PrintPointer(obj->GetVertexColors()); PrintPointer(obj->GetVertexColors());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tColors\n", obj->GetVertexCount() * CKSizeof(LibCmo::CKDWORD)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tColors", obj->GetVertexCount() * CKSizeof(LibCmo::CKDWORD));
PrintPointer(obj->GetVertexSpecularColors()); PrintPointer(obj->GetVertexSpecularColors());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tSpecularColors\n", obj->GetVertexCount() * CKSizeof(LibCmo::CKDWORD)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tSpecularColors", obj->GetVertexCount() * CKSizeof(LibCmo::CKDWORD));
// face data // face data
fputs("== Face ==\n", stdout); Console::WriteLine(u8"== Face ==");
fprintf(stdout, "Face Count: %" PRIuCKDWORD "\n", obj->GetFaceCount()); Console::FormatLine(u8"Face Count: %" PRIuCKDWORD, obj->GetFaceCount());
fputs("Address\tSize\tType\n", stdout); Console::WriteLine(u8"Address\tSize\tType");
PrintPointer(obj->GetFaceIndices()); PrintPointer(obj->GetFaceIndices());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tIndices\n", obj->GetFaceCount() * 3 * CKSizeof(LibCmo::CKWORD)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tIndices", obj->GetFaceCount() * 3 * CKSizeof(LibCmo::CKWORD));
PrintPointer(obj->GetFaceMaterialSlotIndexs()); PrintPointer(obj->GetFaceMaterialSlotIndexs());
fprintf(stdout, "\t0x%" PRIxCKDWORD " bytes\tMaterialSlotIndexs\n", obj->GetFaceCount() * CKSizeof(LibCmo::CKWORD)); Console::FormatLine(u8"\t0x%" PRIxCKDWORD " bytes\tMaterialSlotIndexs", obj->GetFaceCount() * CKSizeof(LibCmo::CKWORD));
// mtl slot data // mtl slot data
fputs("== Material Slot ==\n", stdout); Console::WriteLine(u8"== Material Slot ==");
LibCmo::CKDWORD slotcount = obj->GetMaterialSlotCount(); LibCmo::CKDWORD slotcount = obj->GetMaterialSlotCount();
LibCmo::CK2::ObjImpls::CKMaterial** pMtlSlots = obj->GetMaterialSlots(); LibCmo::CK2::ObjImpls::CKMaterial** pMtlSlots = obj->GetMaterialSlots();
fprintf(stdout, "Material Slot Count: %" PRIuCKDWORD "\n", slotcount); Console::FormatLine(u8"Material Slot Count: %" PRIuCKDWORD, slotcount);
fputs("Index\tAddress\tName\n", stdout); Console::WriteLine(u8"Index\tAddress\tName");
for (LibCmo::CKDWORD i = 0; i < slotcount; ++i) { for (LibCmo::CKDWORD i = 0; i < slotcount; ++i) {
LibCmo::CK2::ObjImpls::CKMaterial* mtl = pMtlSlots[i]; LibCmo::CK2::ObjImpls::CKMaterial* mtl = pMtlSlots[i];
fprintf(stdout, "#%" PRIuCKDWORD "\t", i); Console::Format(u8"#%" PRIuCKDWORD "\t", i);
PrintPointer(mtl); PrintPointer(mtl);
fputc('\t', stdout); Console::Write(u8"\t");
if (mtl != nullptr) if (mtl != nullptr)
PrintCKSTRING(mtl->GetName()); PrintCKSTRING(mtl->GetName());
fputc('\n', stdout); Console::Write(u8"\n");
} }
} }
@ -372,93 +378,87 @@ namespace Unvirt::StructFormatter {
void PrintCKFileInfo(const LibCmo::CK2::CKFileInfo& fileinfo) { void PrintCKFileInfo(const LibCmo::CK2::CKFileInfo& fileinfo) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileInfo\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKFileInfo"));
fprintf(stdout, "FileVersion: %" PRIuCKDWORD "\n", fileinfo.FileVersion); Console::FormatLine(u8"FileVersion: %" PRIuCKDWORD, fileinfo.FileVersion);
fprintf(stdout, "CKVersion: %02" PRIxCKDWORD "/%02" PRIxCKDWORD "/%04" PRIxCKDWORD "\n", LibCmo::CKDWORD ck_series[3] {
(fileinfo.CKVersion >> 24) & 0xFF, (fileinfo.CKVersion >> 24) & 0xFF,
(fileinfo.CKVersion >> 16) & 0xFF, (fileinfo.CKVersion >> 16) & 0xFF,
(fileinfo.CKVersion >> 0) & 0xFFFF (fileinfo.CKVersion >> 0) & 0xFFFF
};
Console::FormatLine(u8"CKVersion: %02" PRIxCKDWORD "/%02" PRIxCKDWORD "/%04" PRIxCKDWORD,
ck_series[0], ck_series[1], ck_series[2]
); );
LibCmo::CKDWORD product_series[4] { LibCmo::CKDWORD product_series[4] {
(fileinfo.ProductBuild >> 24) & 0xFF, (fileinfo.ProductBuild >> 24) & 0xFF,
(fileinfo.ProductBuild >> 16) & 0xFF, (fileinfo.ProductBuild >> 16) & 0xFF,
(fileinfo.ProductBuild >> 8) & 0xFF, (fileinfo.ProductBuild >> 8) & 0xFF,
(fileinfo.ProductBuild >> 0) & 0xFF, (fileinfo.ProductBuild >> 0) & 0xFF,
}; };
fprintf(stdout, "Product (Version / Build): %" PRIuCKDWORD " / %" PRIuCKDWORD ".%" PRIuCKDWORD ".%" PRIuCKDWORD ".%" PRIuCKDWORD "\n", Console::FormatLine(u8"Product (Version / Build): %" PRIuCKDWORD " / %" PRIuCKDWORD ".%" PRIuCKDWORD ".%" PRIuCKDWORD ".%" PRIuCKDWORD,
fileinfo.ProductVersion, product_series[0], product_series[1], product_series[2], product_series[3] fileinfo.ProductVersion, product_series[0], product_series[1], product_series[2], product_series[3]
); );
fprintf(stdout, "Save Flags: %s\n", AccessibleValue::GetFlagEnumName( Console::FormatLine(u8"Save Flags: %s",
fileinfo.FileWriteMode, AccessibleValue::EnumDesc::CK_FILE_WRITEMODE, ", " AccessibleValue::GetFlagEnumName(fileinfo.FileWriteMode, AccessibleValue::EnumDesc::CK_FILE_WRITEMODE, u8", ").c_str()
).c_str());
fprintf(stdout, "File Size: %s\n", AccessibleValue::GetReadableFileSize(fileinfo.FileSize).c_str());
fprintf(stdout, "Crc: 0x%" PRIxCKDWORD "\n", fileinfo.Crc);
fputc('\n', stdout);
fputs("Hdr1 (Pack / UnPack): ", stdout);
fprintf(stdout, "%s / ", AccessibleValue::GetReadableFileSize(fileinfo.Hdr1PackSize).c_str());
fprintf(stdout, "%s\n", AccessibleValue::GetReadableFileSize(fileinfo.Hdr1UnPackSize).c_str());
fputs("Data (Pack / UnPack): ", stdout);
fprintf(stdout, "%s / ", AccessibleValue::GetReadableFileSize(fileinfo.DataPackSize).c_str());
fprintf(stdout, "%s\n", AccessibleValue::GetReadableFileSize(fileinfo.DataUnPackSize).c_str());
fputc('\n', stdout);
fprintf(stdout, "Manager Count: %" PRIuCKDWORD "\nObject Count: %" PRIuCKDWORD "\nMax ID Saved: %" PRIuCKID "\n",
fileinfo.ManagerCount, fileinfo.ObjectCount, fileinfo.MaxIDSaved
); );
Console::FormatLine(u8"File Size: %s", AccessibleValue::GetReadableFileSize(fileinfo.FileSize).c_str());
Console::FormatLine(u8"Crc: 0x%" PRIxCKDWORD, fileinfo.Crc);
Console::WriteLine(u8"");
Console::FormatLine(u8"Hdr1 (Pack / UnPack): %s / %s",
AccessibleValue::GetReadableFileSize(fileinfo.Hdr1PackSize).c_str(),
AccessibleValue::GetReadableFileSize(fileinfo.Hdr1UnPackSize).c_str()
);
Console::FormatLine(u8"Data (Pack / UnPack): %s / %s",
AccessibleValue::GetReadableFileSize(fileinfo.DataPackSize).c_str(),
AccessibleValue::GetReadableFileSize(fileinfo.DataUnPackSize).c_str()
);
Console::WriteLine(u8"");
Console::FormatLine(u8"Manager Count: %" PRIuCKDWORD, fileinfo.ManagerCount);
Console::FormatLine(u8"Object Count: %" PRIuCKDWORD, fileinfo.ObjectCount);
Console::FormatLine(u8"Max ID Saved: %" PRIuCKID, fileinfo.MaxIDSaved);
} }
#pragma region Object List Printer #pragma region Object List Printer
static void PrintObjectListHeader(bool full_detail) { static void PrintObjectListHeader(bool full_detail) {
if (full_detail) { if (full_detail) {
fputs("SaveFlags\tOptions\tCK ID\tFile CK ID\tFile Index\tPack Size\tIndex\tType\tCKObject\tCKStateChunk\tName\n", stdout); Console::WriteLine(u8"SaveFlags\tOptions\tCK ID\tFile CK ID\tFile Index\tPack Size\tIndex\tType\tCKObject\tCKStateChunk\tName");
} else { } else {
fputs("Index\tType\tObject\tChunk\tName\n", stdout); Console::WriteLine(u8"Index\tType\tObject\tChunk\tName");
} }
} }
static void PrintObjectListEntry(const LibCmo::CK2::CKFileObject& obj, const LibCmo::CK2::CKFileInfo& fileinfo, size_t entry_index, bool full_detail) { static void PrintObjectListEntry(const LibCmo::CK2::CKFileObject& obj, const LibCmo::CK2::CKFileInfo& fileinfo, size_t entry_index, bool full_detail) {
if (full_detail) { if (full_detail) {
fprintf(stdout, "0x%08" PRIxCKDWORD "\t", obj.SaveFlags); Console::FormatLine(u8"0x%08" PRIxCKDWORD, obj.SaveFlags);
fputs(AccessibleValue::GetEnumName(obj.Options, AccessibleValue::EnumDesc::CK_FO_OPTIONS).c_str(), stdout); Console::FormatLine(u8"\t%s", AccessibleValue::GetEnumName(obj.Options, AccessibleValue::EnumDesc::CK_FO_OPTIONS).c_str());
fputc('\t', stdout);
fprintf(stdout, "%" PRIuCKID "\t", obj.CreatedObjectId); Console::FormatLine(u8"\t%" PRIuCKID "\t%" PRIuCKID,
fprintf(stdout, "%" PRIuCKID "\t", obj.ObjectId); obj.CreatedObjectId,
obj.ObjectId
);
fprintf(stdout, "0x%08" PRIxCKDWORD " (Rel: 0x%08" PRIxCKDWORD ")\t", Console::FormatLine(u8"\t0x%08" PRIxCKDWORD " (Rel: 0x%08" PRIxCKDWORD ")",
obj.FileIndex, obj.FileIndex,
obj.FileIndex - CKSizeof(LibCmo::CK2::CKRawFileInfo) - fileinfo.Hdr1UnPackSize); obj.FileIndex - CKSizeof(LibCmo::CK2::CKRawFileInfo) - fileinfo.Hdr1UnPackSize
fprintf(stdout, "0x%08" PRIxCKDWORD "\t", obj.PackSize); );
Console::FormatLine(u8"\t0x%08" PRIxCKDWORD, obj.PackSize);
fprintf(stdout, "#%" PRIuSIZET "\t", entry_index);
fputs(AccessibleValue::GetClassIdName(obj.ObjectCid).c_str(), stdout);
fputc('\t', stdout);
PrintPointer(obj.ObjPtr);
fputc('\t', stdout);
PrintPointer(obj.Data);
fputc('\t', stdout);
PrintCKSTRING(LibCmo::XContainer::NSXString::ToCKSTRING(obj.Name));
fputc('\n', stdout);
} else {
fprintf(stdout, "#%" PRIuSIZET "\t", entry_index);
fputs(AccessibleValue::GetClassIdName(obj.ObjectCid).c_str(), stdout);
fputc('\t', stdout);
PrintColorfulBool(obj.ObjPtr != nullptr);
fputc('\t', stdout);
PrintColorfulBool(obj.Data != nullptr);
fputc('\t', stdout);
PrintCKSTRING(LibCmo::XContainer::NSXString::ToCKSTRING(obj.Name));
fputc('\n', stdout);
} }
// following items are shared by full details and simple layout
Console::FormatLine(u8"\t#%" PRIuSIZET "\t%s\t%s\t%s\t%s",
entry_index,
AccessibleValue::GetClassIdName(obj.ObjectCid).c_str(),
PrintColorfulBool(obj.ObjPtr != nullptr).c_str(),
PrintColorfulBool(obj.Data != nullptr).c_str(),
PrintCKSTRING(LibCmo::XContainer::NSXString::ToCKSTRING(obj.Name))
);
} }
void PrintObjectList( void PrintObjectList(
const LibCmo::XContainer::XArray<LibCmo::CK2::CKFileObject>& ls, const LibCmo::XContainer::XArray<LibCmo::CK2::CKFileObject>& ls,
@ -466,7 +466,7 @@ namespace Unvirt::StructFormatter {
size_t page, size_t pageitems, size_t page, size_t pageitems,
bool full_detail) { bool full_detail) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileObject\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKFileObject"));
GeneralPrintList<LibCmo::CK2::CKFileObject>(ls, page, pageitems, GeneralPrintList<LibCmo::CK2::CKFileObject>(ls, page, pageitems,
[full_detail]() -> void { [full_detail]() -> void {
PrintObjectListHeader(full_detail); PrintObjectListHeader(full_detail);
@ -484,7 +484,7 @@ namespace Unvirt::StructFormatter {
size_t page, size_t pageitems, size_t page, size_t pageitems,
bool full_detail) { bool full_detail) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileObject Searching Result\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKFileObject Searching Result"));
GeneralPrintList<size_t>(idxls, page, pageitems, GeneralPrintList<size_t>(idxls, page, pageitems,
[full_detail]() -> void { [full_detail]() -> void {
PrintObjectListHeader(full_detail); PrintObjectListHeader(full_detail);
@ -504,22 +504,22 @@ namespace Unvirt::StructFormatter {
static void PrintManagerListHeader(bool full_detail) { static void PrintManagerListHeader(bool full_detail) {
// manager list now do not affected by list style because it is enough short // manager list now do not affected by list style because it is enough short
fputs("Index\tCKGUID\tCKStateChunk\n", stdout); Console::WriteLine(u8"Index\tCKGUID\tCKStateChunk");
} }
static void PrintManagerListEntry(const LibCmo::CK2::CKFileManagerData& mgr, size_t entry_index, bool full_detail) { static void PrintManagerListEntry(const LibCmo::CK2::CKFileManagerData& mgr, size_t entry_index, bool full_detail) {
// not affected by list style. // not affected by list style.
fprintf(stdout, "#%" PRIuSIZET "\t", entry_index); Console::FormatLine(u8"#%" PRIuSIZET "\t%s\t%s",
PrintCKGUID(mgr.Manager); entry_index,
fputc('\t', stdout); PrintCKGUID(mgr.Manager).c_str(),
PrintPointer(mgr.Data); PrintPointer(mgr.Data).c_str()
fputc('\n', stdout); );
} }
void PrintManagerList( void PrintManagerList(
const LibCmo::XContainer::XArray<LibCmo::CK2::CKFileManagerData>& ls, const LibCmo::XContainer::XArray<LibCmo::CK2::CKFileManagerData>& ls,
size_t page, size_t pageitems, size_t page, size_t pageitems,
bool full_detail) { bool full_detail) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileManager\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKFileManager"));
GeneralPrintList<LibCmo::CK2::CKFileManagerData>(ls, page, pageitems, GeneralPrintList<LibCmo::CK2::CKFileManagerData>(ls, page, pageitems,
[full_detail]() -> void { [full_detail]() -> void {
// print header // print header
@ -538,7 +538,7 @@ namespace Unvirt::StructFormatter {
size_t page, size_t pageitems, size_t page, size_t pageitems,
bool full_detail) { bool full_detail) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileManager Searching Result\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKFileManager Searching Result"));
GeneralPrintList<size_t>(idxls, page, pageitems, GeneralPrintList<size_t>(idxls, page, pageitems,
[full_detail]() -> void { [full_detail]() -> void {
PrintManagerListHeader(full_detail); PrintManagerListHeader(full_detail);
@ -555,7 +555,7 @@ namespace Unvirt::StructFormatter {
void PrintCKObject(const LibCmo::CK2::ObjImpls::CKObject* obj) { void PrintCKObject(const LibCmo::CK2::ObjImpls::CKObject* obj) {
if (obj == nullptr) { if (obj == nullptr) {
fputs(UNVIRT_TERMCOL_LIGHT_RED(("Null Object\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"Null Object"));
return; return;
} }
@ -592,26 +592,26 @@ namespace Unvirt::StructFormatter {
PrintCKMeshDetail(static_cast<LibCmo::CK2::ObjImpls::CKMesh*>(mobj)); PrintCKMeshDetail(static_cast<LibCmo::CK2::ObjImpls::CKMesh*>(mobj));
break; break;
default: default:
fputs(UNVIRT_TERMCOL_LIGHT_RED(("Not Implemented.\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"Not Implemented."));
break; break;
} }
} }
void PrintCKBaseManager(const LibCmo::CK2::MgrImpls::CKBaseManager* mgr) { void PrintCKBaseManager(const LibCmo::CK2::MgrImpls::CKBaseManager* mgr) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKBaseManager\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKBaseManager"));
if (mgr == nullptr) { if (mgr == nullptr) {
fputs(UNVIRT_TERMCOL_LIGHT_RED(("Null Manager\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"Null Manager"));
return; return;
} }
fputs(UNVIRT_TERMCOL_LIGHT_RED(("Not Implemented.\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"Not Implemented."));
} }
void PrintCKStateChunk(const LibCmo::CK2::CKStateChunk* chunk) { void PrintCKStateChunk(const LibCmo::CK2::CKStateChunk* chunk) {
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKStateChunk\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"CKStateChunk"));
if (chunk == nullptr) { if (chunk == nullptr) {
fputs(UNVIRT_TERMCOL_LIGHT_RED(("Null Chunk\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_RED(u8"Null Chunk"));
return; return;
} }
@ -621,42 +621,40 @@ namespace Unvirt::StructFormatter {
// write profile // write profile
const auto profile = operchunk->GetStateChunkProfile(); const auto profile = operchunk->GetStateChunkProfile();
fputs("Type: ", stdout); Console::FormatLine(u8"Type: %s", AccessibleValue::GetClassIdName(profile.m_ClassId).c_str());
fputs(AccessibleValue::GetClassIdName(profile.m_ClassId).c_str(), stdout);
fputc('\n', stdout);
fprintf(stdout, "Version (Data / Chunk): %" PRIuCKDWORD " (%s) / %" PRIuCKDWORD " (%s)\n", Console::FormatLine(u8"Version (Data / Chunk): %" PRIuCKDWORD " (%s) / %" PRIuCKDWORD " (%s)",
static_cast<LibCmo::CKDWORD>(profile.m_DataVersion), AccessibleValue::GetEnumName(profile.m_DataVersion, AccessibleValue::EnumDesc::CK_STATECHUNK_DATAVERSION).c_str(), static_cast<LibCmo::CKDWORD>(profile.m_DataVersion), AccessibleValue::GetEnumName(profile.m_DataVersion, AccessibleValue::EnumDesc::CK_STATECHUNK_DATAVERSION).c_str(),
static_cast<LibCmo::CKDWORD>(profile.m_ChunkVersion), AccessibleValue::GetEnumName(profile.m_ChunkVersion, AccessibleValue::EnumDesc::CK_STATECHUNK_CHUNKVERSION).c_str()); static_cast<LibCmo::CKDWORD>(profile.m_ChunkVersion), AccessibleValue::GetEnumName(profile.m_ChunkVersion, AccessibleValue::EnumDesc::CK_STATECHUNK_CHUNKVERSION).c_str()
fprintf(stdout, "List (Object / Chunk / Manager): %" PRIuCKDWORD " / %" PRIuCKDWORD " / %" PRIuCKDWORD "\n", );
Console::FormatLine(u8"List (Object / Chunk / Manager): %" PRIuCKDWORD " / %" PRIuCKDWORD " / %" PRIuCKDWORD,
static_cast<LibCmo::CKDWORD>(profile.m_ObjectListSize), static_cast<LibCmo::CKDWORD>(profile.m_ObjectListSize),
static_cast<LibCmo::CKDWORD>(profile.m_ChunkListSize), static_cast<LibCmo::CKDWORD>(profile.m_ChunkListSize),
static_cast<LibCmo::CKDWORD>(profile.m_ManagerListSize)); static_cast<LibCmo::CKDWORD>(profile.m_ManagerListSize)
);
fputs("Data: ", stdout); Console::FormatLine(u8"Data: %s (0x%" PRIxCKDWORD " DWORD)",
PrintPointer(profile.m_pData); PrintPointer(profile.m_pData).c_str(),
fprintf(stdout, " (0x%" PRIxCKDWORD " DWORD)\n", profile.m_DataDwSize); profile.m_DataDwSize
);
fputs("Bind CKFile: ", stdout); Console::FormatLine(u8"Bind CKFile: %s", PrintPointer(profile.m_BindFile).c_str());
PrintPointer(profile.m_BindFile); Console::FormatLine(u8"Bind CKContext: %s", PrintPointer(profile.m_BindContext).c_str());
fputc('\n', stdout);
fputs("Bind CKContext: ", stdout);
PrintPointer(profile.m_BindContext);
fputc('\n', stdout);
// write identifiers // write identifiers
operchunk->StartRead(); operchunk->StartRead();
const auto collection = operchunk->GetIdentifiersProfile(); const auto collection = operchunk->GetIdentifiersProfile();
operchunk->StopRead(); operchunk->StopRead();
fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("Identifiers\n")), stdout); Console::WriteLine(YYCC_COLOR_LIGHT_YELLOW(u8"Identifiers"));
fputs("Identifier\tData Pointer\tData Size\n", stdout); Console::WriteLine(u8"Identifier\tData Pointer\tData Size");
for (const auto& ident : collection) { for (const auto& ident : collection) {
fprintf(stdout, "0x%08" PRIxCKDWORD "\t", ident.m_Identifier); Console::FormatLine(u8"0x%08" PRIxCKDWORD "\t%s\t%" PRIuCKDWORD " (%" PRIuCKDWORD " DWORD + %" PRIuCKDWORD ")\n",
PrintPointer(ident.m_DataPtr); ident.m_Identifier,
fputc('\t', stdout); PrintPointer(ident.m_DataPtr).c_str(),
fprintf(stdout, "%" PRIuCKDWORD " (%" PRIuCKDWORD " DWORD + %" PRIuCKDWORD ")\n", ident.m_AreaSize,
ident.m_AreaSize, ident.m_AreaSize / CKSizeof(LibCmo::CKDWORD), ident.m_AreaSize % CKSizeof(LibCmo::CKDWORD)); ident.m_AreaSize / CKSizeof(LibCmo::CKDWORD),
ident.m_AreaSize % CKSizeof(LibCmo::CKDWORD)
);
} }
} }

15
Unvirt/Unvirt.cpp
View File

@ -1,16 +1,21 @@
#include <YYCCommonplace.hpp>
#include "UnvirtContext.hpp" #include "UnvirtContext.hpp"
#include <IronPad.hpp>
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
// start iron pad // register exception handler on windows release
IronPad::IronPadRegister(); #if defined(LIBCMO_BUILD_RELEASE) && (YYCC_OS == YYCC_OS_WINDOWS)
YYCC::ExceptionHelper::Register();
#endif
// run core
Unvirt::Context::UnvirtContext ctx; Unvirt::Context::UnvirtContext ctx;
ctx.Run(); ctx.Run();
// stop iron pad // unregister exception handler on windows release
IronPad::IronPadUnregister(); #if defined(LIBCMO_BUILD_RELEASE) && (YYCC_OS == YYCC_OS_WINDOWS)
YYCC::ExceptionHelper::Register();
#endif
return 0; return 0;
} }