diff --git a/CodeGen/ClassidWriter.java b/CodeGen/ClassidWriter.java index 38b7ec1..56eff70 100644 --- a/CodeGen/ClassidWriter.java +++ b/CodeGen/ClassidWriter.java @@ -5,12 +5,8 @@ import java.util.stream.Collectors; * The nameof values writer for CK_CLASSID. */ public class ClassidWriter { - public static void writeNameofClassid(OutputStreamWriter writer, EnumsHelper.Enum_t classids) throws Exception { + public static void writeAccVals(OutputStreamWriter writer, EnumsHelper.Enum_t classids) throws Exception { IndentHelper indent = new IndentHelper(writer); - indent.puts("struct CkClassidReflection { std::vector mHierarchy; };"); - indent.puts( - "using CkClassidReflectionArray = std::vector>;"); - indent.puts(""); indent.puts("const CkClassidReflectionArray CK_CLASSID {"); indent.inc(); diff --git a/CodeGen/ErrorsWriter.java b/CodeGen/ErrorsWriter.java index 082e342..35a6873 100644 --- a/CodeGen/ErrorsWriter.java +++ b/CodeGen/ErrorsWriter.java @@ -4,13 +4,9 @@ import java.io.OutputStreamWriter; * The nameof values writer for CKERROR */ public class ErrorsWriter { - public static void writeNameofError(OutputStreamWriter writer, EnumsHelper.Enum_t errors) throws Exception { + public static void writeAccVals(OutputStreamWriter writer, EnumsHelper.Enum_t errors) throws Exception { IndentHelper indent = new IndentHelper(writer); - indent.puts("struct CkErrorReflection { const char* mName; const char* mDescription; };"); - indent.puts("using CkErrorReflectionArray = std::vector>;"); - indent.puts(""); - indent.puts("const CkErrorReflectionArray CKERROR {"); indent.inc(); for (EnumsHelper.EnumEntry_t entry : errors.mEntries) { diff --git a/CodeGen/GeneralWriter.java b/CodeGen/GeneralWriter.java index ba5df5e..0ef5da9 100644 --- a/CodeGen/GeneralWriter.java +++ b/CodeGen/GeneralWriter.java @@ -4,6 +4,7 @@ import java.io.OutputStreamWriter; * Generic Enum Writer. Including Data Type Defination and Nameof Values. */ public class GeneralWriter { + public static void writeEnums(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog) throws Exception { IndentHelper indent = new IndentHelper(writer); for (EnumsHelper.Enum_t enum_t : prog.mEnums) { @@ -31,18 +32,29 @@ public class GeneralWriter { // write enum tail indent.dec(); indent.puts("};"); - indent.printf("LIBCMO_BITFLAG_OPERATORS(%s);", enum_t.mEnumName); } } - public static void writeNameofValues(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog, + public static void writeEnum(OutputStreamWriter writer, EnumsHelper.Enum_t _enum) throws Exception { + EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t(); + col.mEnums.add(_enum); + writeEnums(writer, col); + } + + public static void writeAccVals(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog, CommonHelper.CKParts parts) throws Exception { IndentHelper indent = new IndentHelper(writer); + // write decls + for (EnumsHelper.Enum_t enum_t : prog.mEnums) { + indent.printf("extern const GeneralReflectionArray %s;", CommonHelper.getCKPartsNamespace(parts), + enum_t.mEnumName, enum_t.mEnumName); + } - indent.puts("struct GeneralReflection { const char* mName; };"); - indent.puts("template;"); - indent.puts("using GeneralReflectionArray = std::vector>;"); + indent.puts(""); + indent.puts(""); + indent.puts(""); + // write implements for (EnumsHelper.Enum_t enum_t : prog.mEnums) { // write enum desc header indent.printf("const GeneralReflectionArray %s {", CommonHelper.getCKPartsNamespace(parts), @@ -60,4 +72,12 @@ public class GeneralWriter { indent.puts("};"); } } + + public static void writeAccVal(OutputStreamWriter writer, EnumsHelper.Enum_t _enum, CommonHelper.CKParts parts) + throws Exception { + EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t(); + col.mEnums.add(_enum); + writeAccVals(writer, col, parts); + } + } diff --git a/CodeGen/MainRunner.java b/CodeGen/MainRunner.java index 0275c73..5d10b39 100644 --- a/CodeGen/MainRunner.java +++ b/CodeGen/MainRunner.java @@ -38,7 +38,7 @@ public class MainRunner { return result; } - private static EnumsHelper.Enum_t organiseClassid(String infile, String assignedEnumName) throws Exception { + private static EnumsHelper.Enum_t organiseClassid(String infile) throws Exception { CommonHelper.InputFilePair pair = CommonHelper.openInputFile(infile); CKGeneralLexer lexer = new CKGeneralLexer(pair.mAntlrStream); CommonTokenStream tokens = new CommonTokenStream(lexer); @@ -52,61 +52,71 @@ public class MainRunner { pair.mUnderlyingStream.close(); EnumsHelper.Enum_t result = worker.getEnum(); - result.mEnumName = assignedEnumName; + result.mEnumName = "CK_CLASSID"; return result; } public static void main(String[] args) throws Exception { OutputStreamWriter fs = null; - // =========== Read Data =========== - // read enum series first. - // these file are originally is enum in Virtools SDK - EnumsHelper.EnumCollection_t ck2Enums = getEnumsCollection("src/CKEnums.txt"), - vxEnums = getEnumsCollection("src/VxEnums.txt"), - def2 = getEnumsCollection("src/Defines2.txt"); - - // read and reorganize #define type enum - - // read CKERROR standalone. because we need treat it specialized. + // =========== CKERROR =========== EnumsHelper.Enum_t ckerror = organiseDefines("src/CKError.txt", "CKERROR"); - // read CK_CLASSID standalone in another way. - EnumsHelper.Enum_t classid = organiseClassid("src/Classid.txt", "CK_CLASSID"); - // these enum can be directly merge into previous read enum collection - // because we do not need process it independently. - ck2Enums.mEnums.add(organiseDefines("src/CK_STATECHUNK_CHUNKVERSION.txt", "CK_STATECHUNK_CHUNKVERSION")); - ck2Enums.mEnums.add(organiseDefines("src/CK_STATECHUNK_DATAVERSION.txt", "CK_STATECHUNK_DATAVERSION")); - - // =========== Write Nameof Values =========== - // write general accessible values - fs = CommonHelper.openOutputFile("dest/CKEnums.NameofValue.hpp"); - GeneralWriter.writeNameofValues(fs, ck2Enums, CommonHelper.CKParts.CK2); + fs = CommonHelper.openOutputFile("dest/CKError.hpp"); + GeneralWriter.writeEnum(fs, ckerror); fs.close(); - fs = CommonHelper.openOutputFile("dest/VxEnums.NameofValue.hpp"); - GeneralWriter.writeNameofValues(fs, vxEnums, CommonHelper.CKParts.VxMath); - fs.close(); - // write CKERROR - fs = CommonHelper.openOutputFile("dest/CKError.NameofValue.hpp"); - ErrorsWriter.writeNameofError(fs, ckerror); - fs.close(); - // write CK_CLASSID - fs = CommonHelper.openOutputFile("dest/CKClassid.NameofValue.hpp"); - ClassidWriter.writeNameofClassid(fs, classid); + fs = CommonHelper.openOutputFile("dest/CKError.AccVal.hpp"); + ErrorsWriter.writeAccVals(fs, ckerror); fs.close(); - // write data type defines - // CKERROR and CK_CLASSID should be grouped into ck2Enums - ck2Enums.mEnums.add(ckerror); - ck2Enums.mEnums.add(classid); + // =========== CK_CLASSID =========== + EnumsHelper.Enum_t classid = organiseClassid("src/CK_CLASSID.txt"); + fs = CommonHelper.openOutputFile("dest/CK_CLASSID.hpp"); + GeneralWriter.writeEnum(fs, classid); + fs.close(); + fs = CommonHelper.openOutputFile("dest/CK_CLASSID.AccVal.hpp"); + ClassidWriter.writeAccVals(fs, classid); + fs.close(); + + // =========== Define2 =========== + // Define2 do not need values. + EnumsHelper.EnumCollection_t def2 = getEnumsCollection("src/Defines2.txt"); + fs = CommonHelper.openOutputFile("dest/CK_CLASSID.hpp"); + GeneralWriter.writeEnums(fs, def2); + fs.close(); + + // =========== Combined enums =========== + EnumsHelper.EnumCollection_t ck2Enums = getEnumsCollection("src/CKEnums.txt"), + vxEnums = getEnumsCollection("src/VxEnums.txt"); fs = CommonHelper.openOutputFile("dest/CKEnums.hpp"); GeneralWriter.writeEnums(fs, ck2Enums); fs.close(); + fs = CommonHelper.openOutputFile("dest/CKEnums.AccVal.hpp"); + GeneralWriter.writeAccVals(fs, ck2Enums, CommonHelper.CKParts.CK2); + fs.close(); fs = CommonHelper.openOutputFile("dest/VxEnums.hpp"); GeneralWriter.writeEnums(fs, vxEnums); fs.close(); - // Defines2.h need independentlt write - fs = CommonHelper.openOutputFile("dest/Def2.hpp"); - GeneralWriter.writeEnums(fs, def2); + fs = CommonHelper.openOutputFile("dest/VxEnums.AccVal.hpp"); + GeneralWriter.writeAccVals(fs, vxEnums, CommonHelper.CKParts.VxMath); + fs.close(); + + // =========== Single enums =========== + EnumsHelper.Enum_t single; + + single = organiseDefines("src/CK_STATECHUNK_CHUNKVERSION.txt", "CK_STATECHUNK_CHUNKVERSION"); + fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_CHUNKVERSION.hpp"); + GeneralWriter.writeEnum(fs, single); + fs.close(); + fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_CHUNKVERSION.AccVal.hpp"); + GeneralWriter.writeAccVal(fs, single, CommonHelper.CKParts.CK2); + fs.close(); + + single = organiseDefines("src/CK_STATECHUNK_DATAVERSION.txt", "CK_STATECHUNK_DATAVERSION"); + fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_DATAVERSION.hpp"); + GeneralWriter.writeEnum(fs, single); + fs.close(); + fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_DATAVERSION.AccVal.hpp"); + GeneralWriter.writeAccVal(fs, single, CommonHelper.CKParts.CK2); fs.close(); // print message. diff --git a/CodeGen/src/CKENUMS.txt b/CodeGen/src/CKENUMS.txt index 42abb84..b7a2adc 100644 --- a/CodeGen/src/CKENUMS.txt +++ b/CodeGen/src/CKENUMS.txt @@ -54,6 +54,45 @@ typedef enum CK_LOAD_FLAGS { // or because the loaded object already exist in the current level // and the user choose to keep the existing one. }; + +/************************************************* +{filename:CK_LOADMODE} +Summary: Specify the way an object just loaded should be handled when it already exists in the level. +{secret} + +See also: +*************************************************/ +typedef enum CK_LOADMODE +{ + CKLOAD_INVALID=-1,// Use the existing object instead of loading + CKLOAD_OK=0, // Ignore ( Name unicity is broken ) + CKLOAD_REPLACE=1, // Replace the existing object (Not yet implemented) + CKLOAD_RENAME=2, // Rename the loaded object + CKLOAD_USECURRENT=3,// Use the existing object instead of loading +} CK_LOADMODE; + +/************************************************* +{filename:CK_OBJECTCREATION_OPTIONS} +Summary: Specify the way an object is created through CKCreateObject. + +Remarks: + + These flag controls the way an object is created, the most important of these flags + being CK_OBJECTCREATION_DYNAMIC which, if set in CKCreateObject, make the newly created object + dynamic. +See also: CKContext::CreateObject,Dynamic Objects +*************************************************/ +enum CK_OBJECTCREATION_OPTIONS +{ + CK_OBJECTCREATION_NONAMECHECK = 0, // Do not test for name unicity (may be overriden in special case) + CK_OBJECTCREATION_REPLACE = 1, // Replace the current object by the object being loaded + CK_OBJECTCREATION_RENAME = 2, // Rename the created object to ensure its uniqueness + CK_OBJECTCREATION_USECURRENT = 3, // Do not create a new object, use the one with the same name instead + CK_OBJECTCREATION_ASK = 4, // If a duplicate name if found, opens a dialog box to ask the useror use automatic load mode if any. + CK_OBJECTCREATION_FLAGSMASK = 0x0000000F, // Mask for previous values + CK_OBJECTCREATION_DYNAMIC = 0x00000010, // The object must be created dynamic + CK_OBJECTCREATION_ACTIVATE = 0x00000020, // The object will be copied/created active + CK_OBJECTCREATION_NONAMECOPY = 0x00000040 // The object will take control of the string given to it directly, without copying it +}; /************************************************* {filename:CK_PLUGIN_TYPE} diff --git a/CodeGen/src/Classid.txt b/CodeGen/src/CK_CLASSID.txt similarity index 100% rename from CodeGen/src/Classid.txt rename to CodeGen/src/CK_CLASSID.txt diff --git a/LibCmo/CK2/CKFile.hpp b/LibCmo/CK2/CKFile.hpp index 752cc6a..eb0bcda 100644 --- a/LibCmo/CK2/CKFile.hpp +++ b/LibCmo/CK2/CKFile.hpp @@ -168,8 +168,12 @@ namespace LibCmo::CK2 { CKERROR DeepLoad(CKSTRING u8_filename); // ========== Loading Result ========== + CKINT GetSaveIdMax(); const XContainer::XArray& GetFileObjects(); + const XContainer::XArray& GetManagersData(); + const XContainer::XArray& GetPluginsDep(); const XContainer::XArray& GetIncludedFiles(); + const CKFileInfo GetFileInfo(); protected: CKBOOL m_Done; diff --git a/LibCmo/CK2/CKFileOthers.cpp b/LibCmo/CK2/CKFileOthers.cpp index 39fac7e..14a34dc 100644 --- a/LibCmo/CK2/CKFileOthers.cpp +++ b/LibCmo/CK2/CKFileOthers.cpp @@ -129,14 +129,30 @@ namespace LibCmo::CK2 { CKFileReader::~CKFileReader() {} + CKINT CKFileReader::GetSaveIdMax() { + return m_SaveIDMax; + } + const XContainer::XArray& CKFileReader::GetFileObjects() { return m_FileObjects; } + const XContainer::XArray& CKFileReader::GetManagersData() { + return m_ManagersData; + } + + const XContainer::XArray& CKFileReader::GetPluginsDep() { + return m_PluginsDep; + } + const XContainer::XArray& CKFileReader::GetIncludedFiles() { return m_IncludedFiles; } + const CKFileInfo CKFileReader::GetFileInfo() { + return m_FileInfo; + } + #pragma endregion #pragma region CKFileWriter diff --git a/LibCmo/VTUtils.hpp b/LibCmo/VTUtils.hpp index e709a63..86b12ae 100644 --- a/LibCmo/VTUtils.hpp +++ b/LibCmo/VTUtils.hpp @@ -74,7 +74,7 @@ namespace LibCmo { namespace TypeHelper { /** - * @brief HybridString is a compatible type. + * @brief MKString is a compatible type. * In some original Virtools case, we need CKSTRING to hold string. * But CKSTRING is just a pointer and it is very cause memory leak. * So I invent this. It like CKSTRING but will free memory automatically. diff --git a/Unvirt/AccessibleValue.cpp b/Unvirt/AccessibleValue.cpp index 64f7d3c..77f6edb 100644 --- a/Unvirt/AccessibleValue.cpp +++ b/Unvirt/AccessibleValue.cpp @@ -3,280 +3,362 @@ #include #include -namespace Unvirt { - namespace AccessibleValue { +namespace Unvirt::AccessibleValue { -#pragma region universal enum name +#pragma region File Formatter - namespace EnumDesc { - const EnumDescPairArray 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 EnumDescPairArray CK_LOAD_FLAGS{ - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ANIMATION, "CK_LOAD_ANIMATION" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_GEOMETRY, "CK_LOAD_GEOMETRY" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_DEFAULT, "CK_LOAD_DEFAULT" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ASCHARACTER, "CK_LOAD_ASCHARACTER" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_DODIALOG, "CK_LOAD_DODIALOG" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_AS_DYNAMIC_OBJECT, "CK_LOAD_AS_DYNAMIC_OBJECT" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_AUTOMATICMODE, "CK_LOAD_AUTOMATICMODE" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_CHECKDUPLICATES, "CK_LOAD_CHECKDUPLICATES" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_CHECKDEPENDENCIES, "CK_LOAD_CHECKDEPENDENCIES" }, - { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ONLYBEHAVIORS, "CK_LOAD_ONLYBEHAVIORS" } - }; - const EnumDescPairArray CK_FO_OPTIONS{ - { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DEFAULT, "CK_FO_DEFAULT" }, - { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_RENAMEOBJECT, "CK_FO_RENAMEOBJECT" }, - { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_REPLACEOBJECT, "CK_FO_REPLACEOBJECT" }, - { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DONTLOADOBJECT, "CK_FO_DONTLOADOBJECT" } - }; - const EnumDescPairArray CK_PLUGIN_TYPE{ - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_BITMAP_READER, "CKPLUGIN_BITMAP_READER" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_SOUND_READER, "CKPLUGIN_SOUND_READER" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MODEL_READER, "CKPLUGIN_MODEL_READER" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MANAGER_DLL, "CKPLUGIN_MANAGER_DLL" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_BEHAVIOR_DLL, "CKPLUGIN_BEHAVIOR_DLL" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_RENDERENGINE_DLL, "CKPLUGIN_RENDERENGINE_DLL" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MOVIE_READER, "CKPLUGIN_MOVIE_READER" }, - { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_EXTENSION_DLL, "CKPLUGIN_EXTENSION_DLL" } - }; - } + std::string GetReadableFileSize(uint64_t size) { + std::string strl; + static double denominator = (double)0b1111111111; + uint64_t probe = size; -#pragma endregion - -#pragma region class id and ck error - - template - static inline const TValue* GetEnumData(const std::vector>& vec, const TKey key) { - size_t len = vec.size(); - for (size_t i = 0; i < len; ++i) { - if (key == vec[i].first) return &vec[i].second; - } - return nullptr; - } - - static const std::vector>> _CkErrorData{ - { LibCmo::CK2::CKERROR::CKERR_OK, { "CKERR_OK", "Operation successful" } }, - { LibCmo::CK2::CKERROR::CKERR_INVALIDPARAMETER, {"CKERR_INVALIDPARAMETER", "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_INVALIDSIZE, {"CKERR_INVALIDSIZE", "The parameter size was invalid"} }, - { LibCmo::CK2::CKERROR::CKERR_INVALIDOPERATION, {"CKERR_INVALIDOPERATION", "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_OUTOFMEMORY, {"CKERR_OUTOFMEMORY", "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_NOTFOUND, {"CKERR_NOTFOUND", "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_CANCREATERENDERCONTEXT, {"CKERR_CANCREATERENDERCONTEXT", ""} }, - { LibCmo::CK2::CKERROR::CKERR_NOTIFICATIONNOTHANDLED, {"CKERR_NOTIFICATIONNOTHANDLED", "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_INVALIDRENDERCONTEXT, {"CKERR_INVALIDRENDERCONTEXT", "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_NOLOADPLUGINS, {"CKERR_NOLOADPLUGINS", "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_INVALIDFILE, {"CKERR_INVALIDFILE", "attempt to load an invalid file"} }, - { LibCmo::CK2::CKERROR::CKERR_INVALIDPLUGIN, {"CKERR_INVALIDPLUGIN", "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_INVALIDMESSAGE, {"CKERR_INVALIDMESSAGE", "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_NODLLFOUND, {"CKERR_NODLLFOUND", "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_INVALIDDLL, {"CKERR_INVALIDDLL", "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_INVALIDCONDSOLEWINDOW, {"CKERR_INVALIDCONDSOLEWINDOW", "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_NOKEYBOARD, {"CKERR_NOKEYBOARD", "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_NOJOYSTICK, {"CKERR_NOJOYSTICK", "Joystick not attached or not working properly"} }, - { LibCmo::CK2::CKERROR::CKERR_INCOMPATIBLEPARAMETERS, {"CKERR_INCOMPATIBLEPARAMETERS", "Try to link imcompatible Parameters"} }, - { LibCmo::CK2::CKERROR::CKERR_NORENDERENGINE, {"CKERR_NORENDERENGINE", "There is no render engine dll"} }, - { LibCmo::CK2::CKERROR::CKERR_NOCURRENTLEVEL, {"CKERR_NOCURRENTLEVEL", "There is no current level (use CKSetCurrentLevel )"} }, - { LibCmo::CK2::CKERROR::CKERR_SOUNDDISABLED, {"CKERR_SOUNDDISABLED", "Sound Management has been disabled"} }, - { LibCmo::CK2::CKERROR::CKERR_DINPUTDISABLED, {"CKERR_DINPUTDISABLED", "DirectInput Management has been disabled"} }, - { LibCmo::CK2::CKERROR::CKERR_INVALIDGUID, {"CKERR_INVALIDGUID", "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_CANTWRITETOFILE, {"CKERR_CANTWRITETOFILE", "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_INCOMPATIBLECLASSID, {"CKERR_INCOMPATIBLECLASSID", "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_PAUSED, {"CKERR_PAUSED", "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_OBSOLETEVIRTOOLS, {"CKERR_OBSOLETEVIRTOOLS", "Virtools version too old to load this file"} }, - { LibCmo::CK2::CKERROR::CKERR_FILECRCERROR, {"CKERR_FILECRCERROR", "CRC Error while loading file"} }, - { LibCmo::CK2::CKERROR::CKERR_ALREADYFULLSCREEN, {"CKERR_ALREADYFULLSCREEN", "A Render context is already in Fullscreen Mode"} }, - { LibCmo::CK2::CKERROR::CKERR_CANCELLED, {"CKERR_CANCELLED", "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_INVALIDINDEX, {"CKERR_INVALIDINDEX", "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)"} } - }; - - std::string GetCkErrorName(LibCmo::CK2::CKERROR err) { - std::string strl; - const std::array* pErrDesc = GetEnumData>( - _CkErrorData, err - ); - - if (pErrDesc != nullptr) { - strl = pErrDesc->front(); - } else { - strl = c_InvalidEnumName; - } + // check bytes + if ((probe >> 10) == UINT64_C(0)) { + StringHelper::StdstringPrintf(strl, "%" PRIu64 "Bytes", probe); return strl; } + probe >>= 10; - std::string GetCkErrorDescription( LibCmo::CK2::CKERROR err) { - std::string strl; - const std::array* pErrDesc = GetEnumData>( - _CkErrorData, err - ); - - if (pErrDesc != nullptr) { - strl = pErrDesc->back(); - } else { - strl = c_InvalidEnumName; - } + // check kb + if ((probe >> 10) == UINT64_C(0)) { + StringHelper::StdstringPrintf(strl, "%.2lfKiB", size / static_cast(UINT64_C(1) << 10)); return strl; } + probe >>= 10; - static const std::vector>> _CkClassHierarchy{ - { LibCmo::CK2::CK_CLASSID::CKCID_OBJECT, {"CKCID_OBJECT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERIN, {"CKCID_OBJECT", "CKCID_PARAMETERIN"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROPERATION, {"CKCID_OBJECT", "CKCID_PARAMETEROPERATION"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_STATE, {"CKCID_OBJECT", "CKCID_STATE"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORLINK, {"CKCID_OBJECT", "CKCID_BEHAVIORLINK"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIOR, {"CKCID_OBJECT", "CKCID_BEHAVIOR"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORIO, {"CKCID_OBJECT", "CKCID_BEHAVIORIO"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_RENDERCONTEXT, {"CKCID_OBJECT", "CKCID_RENDERCONTEXT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_KINEMATICCHAIN, {"CKCID_OBJECT", "CKCID_KINEMATICCHAIN"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTANIMATION, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_OBJECTANIMATION"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_ANIMATION, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_ANIMATION"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_KEYEDANIMATION, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_ANIMATION", "CKCID_KEYEDANIMATION"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_BEOBJECT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_DATAARRAY, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_DATAARRAY"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SCENE, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SCENE"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_LEVEL, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_LEVEL"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PLACE, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_PLACE"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_GROUP, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_GROUP"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SOUND, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_WAVESOUND, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND", "CKCID_WAVESOUND"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_MIDISOUND, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND", "CKCID_MIDISOUND"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_MATERIAL, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MATERIAL"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_TEXTURE, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_TEXTURE"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_MESH, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MESH"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PATCHMESH, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MESH", "CKCID_PATCHMESH"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_RENDEROBJECT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_2DENTITY, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "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_SPRITETEXT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "CKCID_2DENTITY", "CKCID_SPRITETEXT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_3DENTITY, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_GRID, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_GRID"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_CURVEPOINT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CURVEPOINT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SPRITE3D, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_SPRITE3D"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_CURVE, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CURVE"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_CAMERA, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "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_LIGHT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "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_CHARACTER, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CHARACTER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_3DOBJECT, {"CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "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_PARAMETER, {"CKCID_OBJECT", "CKCID_PARAMETER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERLOCAL, {"CKCID_OBJECT", "CKCID_PARAMETER", "CKCID_PARAMETERLOCAL"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROUT, {"CKCID_OBJECT", "CKCID_PARAMETER", "CKCID_PARAMETEROUT"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_INTERFACEOBJECTMANAGER, {"CKCID_OBJECT", "CKCID_INTERFACEOBJECTMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_CRITICALSECTION, {"CKCID_OBJECT", "CKCID_CRITICALSECTION"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_LAYER, {"CKCID_OBJECT", "CKCID_LAYER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PROGRESSIVEMESH, {"CKCID_OBJECT", "CKCID_PROGRESSIVEMESH"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SYNCHRO, {"CKCID_OBJECT", "CKCID_SYNCHRO"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTARRAY, {"CKCID_OBJECTARRAY"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECTDESC, {"CKCID_SCENEOBJECTDESC"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_ATTRIBUTEMANAGER, {"CKCID_ATTRIBUTEMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_MESSAGEMANAGER, {"CKCID_MESSAGEMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_COLLISIONMANAGER, {"CKCID_COLLISIONMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTMANAGER, {"CKCID_OBJECTMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_FLOORMANAGER, {"CKCID_FLOORMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_RENDERMANAGER, {"CKCID_RENDERMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORMANAGER, {"CKCID_BEHAVIORMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_INPUTMANAGER, {"CKCID_INPUTMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERMANAGER, {"CKCID_PARAMETERMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_GRIDMANAGER, {"CKCID_GRIDMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_SOUNDMANAGER, {"CKCID_SOUNDMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_TIMEMANAGER, {"CKCID_TIMEMANAGER"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_CUIKBEHDATA, {"CKCID_CUIKBEHDATA"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_MAXCLASSID, {"CKCID_MAXCLASSID"} }, - { LibCmo::CK2::CK_CLASSID::CKCID_MAXMAXCLASSID, {"CKCID_MAXMAXCLASSID"} } - }; - - std::string GetClassIdName(LibCmo::CK2::CK_CLASSID cls) { - std::string strl; - const std::vector* pHierarchy = GetEnumData>( - _CkClassHierarchy, cls - ); - - if (pHierarchy != nullptr) { - strl = pHierarchy->back(); - } else { - strl = c_InvalidEnumName; - } + // check mb + if ((probe >> 10) == UINT64_C(0)) { + StringHelper::StdstringPrintf(strl, "%.2lfMiB", size / static_cast(UINT64_C(1) << 20)); return strl; } + probe >>= 10; - std::string GetClassIdHierarchy(LibCmo::CK2::CK_CLASSID cls) { - std::string strl; - const std::vector* pHierarchy = GetEnumData>( - _CkClassHierarchy, cls - ); - - if (pHierarchy != nullptr) { - strl.clear(); - for (auto it = pHierarchy->begin(); it != pHierarchy->end(); ++it) { - if (it != pHierarchy->begin()) strl += " -> "; - strl += (*it); - } - } else { - strl = c_InvalidEnumName; - } - - return strl; - } - -#pragma endregion - - std::string GetAccessibleFileSize(uint64_t size) { - std::string strl; - static double denominator = (double)0b1111111111; - uint64_t probe = size; - - // check bytes - if ((probe >> 10) == UINT64_C(0)) { - StringHelper::StdstringPrintf(strl, "%" PRIu64 "Bytes", probe); - return strl; - } - probe >>= 10; - - // check kb - if ((probe >> 10) == UINT64_C(0)) { - StringHelper::StdstringPrintf(strl, "%.2lfKiB", size / static_cast(UINT64_C(1) << 10)); - return strl; - } - probe >>= 10; - - // check mb - if ((probe >> 10) == UINT64_C(0)) { - StringHelper::StdstringPrintf(strl, "%.2lfMiB", size / static_cast(UINT64_C(1) << 20)); - return strl; - } - probe >>= 10; - - // otherwise gb - StringHelper::StdstringPrintf(strl, "%.2lfGiB", size / static_cast(UINT64_C(1) << 30)); - return strl; - - } + // otherwise gb + StringHelper::StdstringPrintf(strl, "%.2lfGiB", size / static_cast(UINT64_C(1) << 30)); + return strl; } + +#pragma endregion + +#pragma region CKERROR CK_CLASSID Data + + struct CkClassidReflection { std::vector mHierarchy; }; + using CkClassidReflectionArray = std::vector>; + + struct CkErrorReflection { const char* mName; const char* mDescription; }; + using CkErrorReflectionArray = std::vector>; + + namespace EnumDesc { + + const CkClassidReflectionArray CK_CLASSID { + { LibCmo::CK2::CK_CLASSID::CKCID_OBJECT, { { "CKCID_OBJECT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERIN, { { "CKCID_OBJECT", "CKCID_PARAMETERIN" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROPERATION, { { "CKCID_OBJECT", "CKCID_PARAMETEROPERATION" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_STATE, { { "CKCID_OBJECT", "CKCID_STATE" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORLINK, { { "CKCID_OBJECT", "CKCID_BEHAVIORLINK" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIOR, { { "CKCID_OBJECT", "CKCID_BEHAVIOR" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORIO, { { "CKCID_OBJECT", "CKCID_BEHAVIORIO" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_RENDERCONTEXT, { { "CKCID_OBJECT", "CKCID_RENDERCONTEXT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_KINEMATICCHAIN, { { "CKCID_OBJECT", "CKCID_KINEMATICCHAIN" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTANIMATION, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_OBJECTANIMATION" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_ANIMATION, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_ANIMATION" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_KEYEDANIMATION, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_ANIMATION", "CKCID_KEYEDANIMATION" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_BEOBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_DATAARRAY, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_DATAARRAY" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SCENE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SCENE" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_LEVEL, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_LEVEL" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PLACE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_PLACE" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_GROUP, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_GROUP" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SOUND, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_WAVESOUND, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND", "CKCID_WAVESOUND" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_MIDISOUND, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_SOUND", "CKCID_MIDISOUND" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_MATERIAL, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MATERIAL" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_TEXTURE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_TEXTURE" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_MESH, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MESH" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PATCHMESH, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_MESH", "CKCID_PATCHMESH" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_RENDEROBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_2DENTITY, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "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_SPRITETEXT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_RENDEROBJECT", "CKCID_2DENTITY", "CKCID_SPRITETEXT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_3DENTITY, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_GRID, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_GRID" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_CURVEPOINT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CURVEPOINT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SPRITE3D, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_SPRITE3D" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_CURVE, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CURVE" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_CAMERA, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "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_LIGHT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "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_CHARACTER, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "CKCID_CHARACTER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_3DOBJECT, { { "CKCID_OBJECT", "CKCID_SCENEOBJECT", "CKCID_BEOBJECT", "CKCID_3DENTITY", "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_PARAMETER, { { "CKCID_OBJECT", "CKCID_PARAMETER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERLOCAL, { { "CKCID_OBJECT", "CKCID_PARAMETER", "CKCID_PARAMETERLOCAL" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETEROUT, { { "CKCID_OBJECT", "CKCID_PARAMETER", "CKCID_PARAMETEROUT" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_INTERFACEOBJECTMANAGER, { { "CKCID_OBJECT", "CKCID_INTERFACEOBJECTMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_CRITICALSECTION, { { "CKCID_OBJECT", "CKCID_CRITICALSECTION" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_LAYER, { { "CKCID_OBJECT", "CKCID_LAYER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PROGRESSIVEMESH, { { "CKCID_OBJECT", "CKCID_PROGRESSIVEMESH" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SYNCHRO, { { "CKCID_OBJECT", "CKCID_SYNCHRO" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTARRAY, { { "CKCID_OBJECTARRAY" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SCENEOBJECTDESC, { { "CKCID_SCENEOBJECTDESC" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_ATTRIBUTEMANAGER, { { "CKCID_ATTRIBUTEMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_MESSAGEMANAGER, { { "CKCID_MESSAGEMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_COLLISIONMANAGER, { { "CKCID_COLLISIONMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_OBJECTMANAGER, { { "CKCID_OBJECTMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_FLOORMANAGER, { { "CKCID_FLOORMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_RENDERMANAGER, { { "CKCID_RENDERMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_BEHAVIORMANAGER, { { "CKCID_BEHAVIORMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_INPUTMANAGER, { { "CKCID_INPUTMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_PARAMETERMANAGER, { { "CKCID_PARAMETERMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_GRIDMANAGER, { { "CKCID_GRIDMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_SOUNDMANAGER, { { "CKCID_SOUNDMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_TIMEMANAGER, { { "CKCID_TIMEMANAGER" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_CUIKBEHDATA, { { "CKCID_CUIKBEHDATA" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_MAXCLASSID, { { "CKCID_MAXCLASSID" } } }, + { LibCmo::CK2::CK_CLASSID::CKCID_MAXMAXCLASSID, { { "CKCID_MAXMAXCLASSID" } } }, + }; + + const CkErrorReflectionArray CKERROR { + { LibCmo::CK2::CKERROR::CKERR_OK, { "CKERR_OK", "Operation successful " } }, + { LibCmo::CK2::CKERROR::CKERR_INVALIDPARAMETER, { "CKERR_INVALIDPARAMETER", "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_INVALIDSIZE, { "CKERR_INVALIDSIZE", "The parameter size was invalid " } }, + { LibCmo::CK2::CKERROR::CKERR_INVALIDOPERATION, { "CKERR_INVALIDOPERATION", "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_OUTOFMEMORY, { "CKERR_OUTOFMEMORY", "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_NOTFOUND, { "CKERR_NOTFOUND", "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_CANCREATERENDERCONTEXT, { "CKERR_CANCREATERENDERCONTEXT", " " } }, + { LibCmo::CK2::CKERROR::CKERR_NOTIFICATIONNOTHANDLED, { "CKERR_NOTIFICATIONNOTHANDLED", "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_INVALIDRENDERCONTEXT, { "CKERR_INVALIDRENDERCONTEXT", "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_NOLOADPLUGINS, { "CKERR_NOLOADPLUGINS", "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_INVALIDFILE, { "CKERR_INVALIDFILE", "attempt to load an invalid file " } }, + { LibCmo::CK2::CKERROR::CKERR_INVALIDPLUGIN, { "CKERR_INVALIDPLUGIN", "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_INVALIDMESSAGE, { "CKERR_INVALIDMESSAGE", "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_NODLLFOUND, { "CKERR_NODLLFOUND", "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_INVALIDDLL, { "CKERR_INVALIDDLL", "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_INVALIDCONDSOLEWINDOW, { "CKERR_INVALIDCONDSOLEWINDOW", "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_NOKEYBOARD, { "CKERR_NOKEYBOARD", "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_NOJOYSTICK, { "CKERR_NOJOYSTICK", "Joystick not attached or not working properly " } }, + { LibCmo::CK2::CKERROR::CKERR_INCOMPATIBLEPARAMETERS, { "CKERR_INCOMPATIBLEPARAMETERS", "Try to link imcompatible Parameters " } }, + { LibCmo::CK2::CKERROR::CKERR_NORENDERENGINE, { "CKERR_NORENDERENGINE", "There is no render engine dll " } }, + { LibCmo::CK2::CKERROR::CKERR_NOCURRENTLEVEL, { "CKERR_NOCURRENTLEVEL", "There is no current level (use CKSetCurrentLevel ) " } }, + { LibCmo::CK2::CKERROR::CKERR_SOUNDDISABLED, { "CKERR_SOUNDDISABLED", "Sound Management has been disabled " } }, + { LibCmo::CK2::CKERROR::CKERR_DINPUTDISABLED, { "CKERR_DINPUTDISABLED", "DirectInput Management has been disabled " } }, + { LibCmo::CK2::CKERROR::CKERR_INVALIDGUID, { "CKERR_INVALIDGUID", "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_CANTWRITETOFILE, { "CKERR_CANTWRITETOFILE", "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_INCOMPATIBLECLASSID, { "CKERR_INCOMPATIBLECLASSID", "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_PAUSED, { "CKERR_PAUSED", "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_OBSOLETEVIRTOOLS, { "CKERR_OBSOLETEVIRTOOLS", "Virtools version too old to load this file " } }, + { LibCmo::CK2::CKERROR::CKERR_FILECRCERROR, { "CKERR_FILECRCERROR", "CRC Error while loading file " } }, + { LibCmo::CK2::CKERROR::CKERR_ALREADYFULLSCREEN, { "CKERR_ALREADYFULLSCREEN", "A Render context is already in Fullscreen Mode " } }, + { LibCmo::CK2::CKERROR::CKERR_CANCELLED, { "CKERR_CANCELLED", "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_INVALIDINDEX, { "CKERR_INVALIDINDEX", "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) " } }, + }; + + } + +#pragma endregion + +#pragma region CKERROR CK_CLASSID Process + + static const CkErrorReflection* GetCkError(LibCmo::CK2::CKERROR err) { + for (auto& item : EnumDesc::CKERROR) { + if (item.first == err) { + return &item.second; + } + } + return nullptr; + } + + std::string GetCkErrorName(LibCmo::CK2::CKERROR err) { + const CkErrorReflection* node = GetCkError(err); + if (node != nullptr) return node->mName; + else return c_InvalidEnumName; + } + + std::string GetCkErrorDescription(LibCmo::CK2::CKERROR err) { + const CkErrorReflection* node = GetCkError(err); + if (node != nullptr) return node->mDescription; + else return c_InvalidEnumName; + } + + static const CkClassidReflection* GetCkClassid(LibCmo::CK2::CK_CLASSID cls) { + for (auto& item : EnumDesc::CK_CLASSID) { + if (item.first == cls) { + return &item.second; + } + } + return nullptr; + } + + std::string GetClassIdName(LibCmo::CK2::CK_CLASSID cls) { + const CkClassidReflection* node = GetCkClassid(cls); + if (node == nullptr) return c_InvalidEnumName; + else return node->mHierarchy.back(); + } + + std::string GetClassIdHierarchy(LibCmo::CK2::CK_CLASSID cls) { + const CkClassidReflection* node = GetCkClassid(cls); + if (node == nullptr) return c_InvalidEnumName; + + std::string strl; + for (auto& hierarchy_node : node->mHierarchy) { + if (!strl.empty()) strl += " -> "; + strl += hierarchy_node; + } + return strl; + } + +#pragma endregion + +#pragma region Other Enums + + namespace EnumDesc { + + const GeneralReflectionArray 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 GeneralReflectionArray CK_LOAD_FLAGS { + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ANIMATION, {"CK_LOAD_ANIMATION"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_GEOMETRY, {"CK_LOAD_GEOMETRY"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_DEFAULT, {"CK_LOAD_DEFAULT"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ASCHARACTER, {"CK_LOAD_ASCHARACTER"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_DODIALOG, {"CK_LOAD_DODIALOG"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_AS_DYNAMIC_OBJECT, {"CK_LOAD_AS_DYNAMIC_OBJECT"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_AUTOMATICMODE, {"CK_LOAD_AUTOMATICMODE"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_CHECKDUPLICATES, {"CK_LOAD_CHECKDUPLICATES"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_CHECKDEPENDENCIES, {"CK_LOAD_CHECKDEPENDENCIES"} }, + { LibCmo::CK2::CK_LOAD_FLAGS::CK_LOAD_ONLYBEHAVIORS, {"CK_LOAD_ONLYBEHAVIORS"} }, + }; + const GeneralReflectionArray CK_FO_OPTIONS { + { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DEFAULT, {"CK_FO_DEFAULT"} }, + { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_RENAMEOBJECT, {"CK_FO_RENAMEOBJECT"} }, + { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_REPLACEOBJECT, {"CK_FO_REPLACEOBJECT"} }, + { LibCmo::CK2::CK_FO_OPTIONS::CK_FO_DONTLOADOBJECT, {"CK_FO_DONTLOADOBJECT"} }, + }; + const GeneralReflectionArray CK_LOADMODE { + { LibCmo::CK2::CK_LOADMODE::CKLOAD_INVALID, {"CKLOAD_INVALID"} }, + { LibCmo::CK2::CK_LOADMODE::CKLOAD_OK, {"CKLOAD_OK"} }, + { LibCmo::CK2::CK_LOADMODE::CKLOAD_REPLACE, {"CKLOAD_REPLACE"} }, + { LibCmo::CK2::CK_LOADMODE::CKLOAD_RENAME, {"CKLOAD_RENAME"} }, + { LibCmo::CK2::CK_LOADMODE::CKLOAD_USECURRENT, {"CKLOAD_USECURRENT"} }, + }; + const GeneralReflectionArray CK_OBJECTCREATION_OPTIONS { + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_NONAMECHECK, {"CK_OBJECTCREATION_NONAMECHECK"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_REPLACE, {"CK_OBJECTCREATION_REPLACE"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_RENAME, {"CK_OBJECTCREATION_RENAME"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_USECURRENT, {"CK_OBJECTCREATION_USECURRENT"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_ASK, {"CK_OBJECTCREATION_ASK"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_FLAGSMASK, {"CK_OBJECTCREATION_FLAGSMASK"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_DYNAMIC, {"CK_OBJECTCREATION_DYNAMIC"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_ACTIVATE, {"CK_OBJECTCREATION_ACTIVATE"} }, + { LibCmo::CK2::CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_NONAMECOPY, {"CK_OBJECTCREATION_NONAMECOPY"} }, + }; + const GeneralReflectionArray CK_PLUGIN_TYPE { + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_BITMAP_READER, {"CKPLUGIN_BITMAP_READER"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_SOUND_READER, {"CKPLUGIN_SOUND_READER"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MODEL_READER, {"CKPLUGIN_MODEL_READER"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MANAGER_DLL, {"CKPLUGIN_MANAGER_DLL"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_BEHAVIOR_DLL, {"CKPLUGIN_BEHAVIOR_DLL"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_RENDERENGINE_DLL, {"CKPLUGIN_RENDERENGINE_DLL"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_MOVIE_READER, {"CKPLUGIN_MOVIE_READER"} }, + { LibCmo::CK2::CK_PLUGIN_TYPE::CKPLUGIN_EXTENSION_DLL, {"CKPLUGIN_EXTENSION_DLL"} }, + }; + const GeneralReflectionArray CK_STATECHUNK_CHUNKOPTIONS { + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_IDS, {"CHNK_OPTION_IDS"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_MAN, {"CHNK_OPTION_MAN"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_CHN, {"CHNK_OPTION_CHN"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_FILE, {"CHNK_OPTION_FILE"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_ALLOWDYN, {"CHNK_OPTION_ALLOWDYN"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_OPTION_LISTBIG, {"CHNK_OPTION_LISTBIG"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_DONTDELETE_PTR, {"CHNK_DONTDELETE_PTR"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKOPTIONS::CHNK_DONTDELETE_PARSER, {"CHNK_DONTDELETE_PARSER"} }, + }; + const GeneralReflectionArray CK_OBJECT_FLAGS { + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_INTERFACEOBJ, {"CK_OBJECT_INTERFACEOBJ"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_PRIVATE, {"CK_OBJECT_PRIVATE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_INTERFACEMARK, {"CK_OBJECT_INTERFACEMARK"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_FREEID, {"CK_OBJECT_FREEID"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_TOBEDELETED, {"CK_OBJECT_TOBEDELETED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBESAVED, {"CK_OBJECT_NOTTOBESAVED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_VISIBLE, {"CK_OBJECT_VISIBLE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NAMESHARED, {"CK_OBJECT_NAMESHARED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_DYNAMIC, {"CK_OBJECT_DYNAMIC"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_HIERACHICALHIDE, {"CK_OBJECT_HIERACHICALHIDE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_UPTODATE, {"CK_OBJECT_UPTODATE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_TEMPMARKER, {"CK_OBJECT_TEMPMARKER"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_ONLYFORFILEREFERENCE, {"CK_OBJECT_ONLYFORFILEREFERENCE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBEDELETED, {"CK_OBJECT_NOTTOBEDELETED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_APPDATA, {"CK_OBJECT_APPDATA"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_SINGLEACTIVITY, {"CK_OBJECT_SINGLEACTIVITY"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_LOADSKIPBEOBJECT, {"CK_OBJECT_LOADSKIPBEOBJECT"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_NOTTOBELISTEDANDSAVED, {"CK_OBJECT_NOTTOBELISTEDANDSAVED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_SETTINGS, {"CK_PARAMETEROUT_SETTINGS"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_PARAMOP, {"CK_PARAMETEROUT_PARAMOP"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_DISABLED, {"CK_PARAMETERIN_DISABLED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_THIS, {"CK_PARAMETERIN_THIS"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETERIN_SHARED, {"CK_PARAMETERIN_SHARED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_PARAMETEROUT_DELETEAFTERUSE, {"CK_PARAMETEROUT_DELETEAFTERUSE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_PARAMMASK, {"CK_OBJECT_PARAMMASK"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_IN, {"CK_BEHAVIORIO_IN"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_OUT, {"CK_BEHAVIORIO_OUT"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_BEHAVIORIO_ACTIVE, {"CK_BEHAVIORIO_ACTIVE"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_IOTYPEMASK, {"CK_OBJECT_IOTYPEMASK"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_IOMASK, {"CK_OBJECT_IOMASK"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CKBEHAVIORLINK_RESERVED, {"CKBEHAVIORLINK_RESERVED"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CKBEHAVIORLINK_ACTIVATEDLASTFRAME, {"CKBEHAVIORLINK_ACTIVATEDLASTFRAME"} }, + { LibCmo::CK2::CK_OBJECT_FLAGS::CK_OBJECT_BEHAVIORLINKMASK, {"CK_OBJECT_BEHAVIORLINKMASK"} }, + }; + + const GeneralReflectionArray CK_STATECHUNK_DATAVERSION { + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_OLDVERSION, {"CHUNKDATA_OLDVERSION"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_BASEVERSION, {"CHUNKDATA_BASEVERSION"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION2, {"CHUNK_WAVESOUND_VERSION2"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION3, {"CHUNK_WAVESOUND_VERSION3"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MATERIAL_VERSION_ZTEST, {"CHUNK_MATERIAL_VERSION_ZTEST"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MAJORCHANGE_VERSION, {"CHUNK_MAJORCHANGE_VERSION"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MACCHANGE_VERSION, {"CHUNK_MACCHANGE_VERSION"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_WAVESOUND_VERSION4, {"CHUNK_WAVESOUND_VERSION4"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_SCENECHANGE_VERSION, {"CHUNK_SCENECHANGE_VERSION"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_MESHCHANGE_VERSION, {"CHUNK_MESHCHANGE_VERSION"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNK_DEV_2_1, {"CHUNK_DEV_2_1"} }, + { LibCmo::CK2::CK_STATECHUNK_DATAVERSION::CHUNKDATA_CURRENTVERSION, {"CHUNKDATA_CURRENTVERSION"} }, + }; + + const GeneralReflectionArray CK_STATECHUNK_CHUNKVERSION { + { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSIONBASE, {"CHUNK_VERSIONBASE"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION1, {"CHUNK_VERSION1"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION2, {"CHUNK_VERSION2"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION3, {"CHUNK_VERSION3"} }, + { LibCmo::CK2::CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4, {"CHUNK_VERSION4"} }, + }; + + } + +#pragma endregion + } diff --git a/Unvirt/AccessibleValue.hpp b/Unvirt/AccessibleValue.hpp index cc5a1c4..a60a2ff 100644 --- a/Unvirt/AccessibleValue.hpp +++ b/Unvirt/AccessibleValue.hpp @@ -1,7 +1,6 @@ #pragma once -#include -#include +#include #include #include @@ -10,63 +9,68 @@ namespace Unvirt { constexpr const char c_InvalidEnumName[] = "[undefined]"; -#pragma region universal enum name + struct GeneralReflection { const char* mName; }; + template + using GeneralReflectionArray = std::vector>; - template - using EnumDescPairArray = std::vector>; - - namespace EnumDesc { - extern const EnumDescPairArray CK_FILE_WRITEMODE; - extern const EnumDescPairArray CK_LOAD_FLAGS; - extern const EnumDescPairArray CK_FO_OPTIONS; - extern const EnumDescPairArray CK_PLUGIN_TYPE; - } - - template - std::string GetEnumName(const EnumDescPairArray& desc, TEnum val) { + template + std::string GetEnumName(_Ty val, const GeneralReflectionArray<_Ty>& desc) { std::string strl; - for (auto it = desc.begin(); it != desc.end(); ++it) { - if ((*it).first == val) { - strl = (*it).second; + for (auto& item : desc) { + if (item.first == val) { + strl = item.second.mName; return strl; } } strl = c_InvalidEnumName; return strl; } - template - std::string GetFlagEnumName(const EnumDescPairArray& desc, TEnum val) { + template + std::string GetFlagEnumName(_Ty val, const GeneralReflectionArray<_Ty>& desc) { std::string strl; - for (auto it = desc.begin(); it != desc.end(); ++it) { + for (auto& item : desc) { // if it have exacelt same entry, return directly - if ((*it).first == val) { - strl = (*it).second; + if (item.first == val) { + strl = item.second.mName; return strl; } // check flag match - if (LibCmo::EnumsHelper::FlagEnumHas(val, (*it).first)) { - // matched, add it + if (LibCmo::EnumsHelper::Has(val, item.first)) { if (strl.size() != 0u) strl += ", "; - strl += (*it).second; + strl += item.second.mName; } } + // if nothing was gotten. set to undefined if (strl.size() == 0u) { - // nothing was gotten. set to undefined strl = c_InvalidEnumName; - } // otherwise return directly + } + return strl; } -#pragma endregion - 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 GetAccessibleFileSize(uint64_t size); + std::string GetReadableFileSize(uint64_t size); + + namespace EnumDesc { + extern const GeneralReflectionArray CK_FILE_WRITEMODE; + extern const GeneralReflectionArray CK_LOAD_FLAGS; + extern const GeneralReflectionArray CK_FO_OPTIONS; + extern const GeneralReflectionArray CK_LOADMODE; + extern const GeneralReflectionArray CK_OBJECTCREATION_OPTIONS; + extern const GeneralReflectionArray CK_PLUGIN_TYPE; + extern const GeneralReflectionArray CK_STATECHUNK_CHUNKOPTIONS; + extern const GeneralReflectionArray CK_OBJECT_FLAGS; + + extern const GeneralReflectionArray CK_STATECHUNK_DATAVERSION; + + extern const GeneralReflectionArray CK_STATECHUNK_CHUNKVERSION; + } } } diff --git a/Unvirt/StructFormatter.cpp b/Unvirt/StructFormatter.cpp index 5d57061..a8cfb70 100644 --- a/Unvirt/StructFormatter.cpp +++ b/Unvirt/StructFormatter.cpp @@ -1,3 +1,4 @@ +#include #include "StructFormatter.hpp" #include "AccessibleValue.hpp" #include "TerminalHelper.hpp" @@ -26,23 +27,23 @@ namespace Unvirt::StructFormatter { fileinfo.ProductVersion, product_series[0], product_series[1], product_series[2], product_series[3] ); - fprintf(fout, "Save Flags: %s\n", Unvirt::AccessibleValue::GetFlagEnumName( - Unvirt::AccessibleValue::EnumDesc::CK_FILE_WRITEMODE, fileinfo.FileWriteMode + fprintf(fout, "Save Flags: %s\n", Unvirt::AccessibleValue::GetFlagEnumName( + fileinfo.FileWriteMode, Unvirt::AccessibleValue::EnumDesc::CK_FILE_WRITEMODE ).c_str()); - fprintf(fout, "File Size: %s\n", Unvirt::AccessibleValue::GetAccessibleFileSize(fileinfo.FileSize).c_str()); + fprintf(fout, "File Size: %s\n", Unvirt::AccessibleValue::GetReadableFileSize(fileinfo.FileSize).c_str()); fprintf(fout, "Crc: 0x%" PRIX32 "\n", fileinfo.Crc); fputc('\n', fout); fputs("Hdr1 (Pack / UnPack): ", fout); - fprintf(fout, "%s / ", Unvirt::AccessibleValue::GetAccessibleFileSize(fileinfo.Hdr1PackSize).c_str()); - fprintf(fout, "%s\n", Unvirt::AccessibleValue::GetAccessibleFileSize(fileinfo.Hdr1UnPackSize).c_str()); + fprintf(fout, "%s / ", Unvirt::AccessibleValue::GetReadableFileSize(fileinfo.Hdr1PackSize).c_str()); + fprintf(fout, "%s\n", Unvirt::AccessibleValue::GetReadableFileSize(fileinfo.Hdr1UnPackSize).c_str()); fputs("Data (Pack / UnPack): ", fout); - fprintf(fout, "%s / ", Unvirt::AccessibleValue::GetAccessibleFileSize(fileinfo.DataPackSize).c_str()); - fprintf(fout, "%s\n", Unvirt::AccessibleValue::GetAccessibleFileSize(fileinfo.DataUnPackSize).c_str()); + fprintf(fout, "%s / ", Unvirt::AccessibleValue::GetReadableFileSize(fileinfo.DataPackSize).c_str()); + fprintf(fout, "%s\n", Unvirt::AccessibleValue::GetReadableFileSize(fileinfo.DataUnPackSize).c_str()); fputc('\n', fout); @@ -52,12 +53,18 @@ namespace Unvirt::StructFormatter { } - static void PrintCKSTRING(const std::string& name) { - if (name.empty()) { + static void PrintCKSTRING(const LibCmo::TypeHelper::MKString& name) { + LibCmo::CK2::CKSTRING ckname = name.c_str(); + if (ckname == nullptr) { fputs(UNVIRT_TERMCOL_LIGHT_MAGENTA(("")), fout); } else { - fputs(name.c_str(), fout); + fputs(ckname, fout); } + //if (name.empty()) { + // fputs(UNVIRT_TERMCOL_LIGHT_MAGENTA(("")), fout); + //} else { + // fputs(name.c_str(), fout); + //} } static void PrintPointer(const void* ptr) { if (ptr == nullptr) { @@ -70,7 +77,7 @@ namespace Unvirt::StructFormatter { fprintf(stdout, "<0x%08" PRIx32 ", 0x%08" PRIx32 ">", guid.d1, guid.d2); } - void PrintObjectList(const LibCmo::CK2::XArray& ls, size_t page, size_t pageitems) { + void PrintObjectList(const LibCmo::XContainer::XArray& ls, size_t page, size_t pageitems) { fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileObject\n")), fout); size_t fulllen = ls.size(), @@ -97,7 +104,7 @@ namespace Unvirt::StructFormatter { fprintf(fout, "Page %zu of %zu\n", page + 1, fullpage + 1); } - void PrintManagerList(const LibCmo::CK2::XArray& ls, size_t page, size_t pageitems) { + void PrintManagerList(const LibCmo::XContainer::XArray& ls, size_t page, size_t pageitems) { fputs(UNVIRT_TERMCOL_LIGHT_YELLOW(("CKFileManager\n")), fout); size_t fulllen = ls.size(), @@ -113,8 +120,6 @@ namespace Unvirt::StructFormatter { PrintCKGUID(mgr.Manager); fputc('\t', fout); - PrintPointer(mgr.MgrPtr); - fputc('\t', fout); PrintPointer(mgr.Data); fputc('\n', fout); } diff --git a/Unvirt/StructFormatter.hpp b/Unvirt/StructFormatter.hpp index 2cf1ee3..f1fd4a2 100644 --- a/Unvirt/StructFormatter.hpp +++ b/Unvirt/StructFormatter.hpp @@ -1,11 +1,12 @@ #pragma once -#include +#include +#include namespace Unvirt::StructFormatter { void PrintCKFileInfo(const LibCmo::CK2::CKFileInfo& fileinfo); - void PrintObjectList(const LibCmo::CK2::XArray& ls, size_t page, size_t pageitems); - void PrintManagerList(const LibCmo::CK2::XArray& ls, size_t page, size_t pageitems); + void PrintObjectList(const LibCmo::XContainer::XArray& ls, size_t page, size_t pageitems); + void PrintManagerList(const LibCmo::XContainer::XArray& ls, size_t page, size_t pageitems); } diff --git a/Unvirt/TerminalHelper.cpp b/Unvirt/TerminalHelper.cpp index 7d1c8a6..4366d33 100644 --- a/Unvirt/TerminalHelper.cpp +++ b/Unvirt/TerminalHelper.cpp @@ -1,6 +1,9 @@ #include "TerminalHelper.hpp" #include +#include #include +#include +#include #if defined(LIBCMO_OS_WIN32) #include @@ -43,5 +46,16 @@ namespace Unvirt { return true; } + void GetCmdLine(std::string& u8cmd) { + fputs("Unvirt> ", stdout); +#if defined(LIBCMO_OS_WIN32) + std::wstring wcmd; + std::getline(std::wcin, wcmd); + LibCmo::EncodingHelper::WcharToChar(wcmd, u8cmd, CP_UTF8); +#else + std::getline(std::cin, u8cmd); +#endif + } + } } \ No newline at end of file diff --git a/Unvirt/TerminalHelper.hpp b/Unvirt/TerminalHelper.hpp index 604dc69..6c6ecda 100644 --- a/Unvirt/TerminalHelper.hpp +++ b/Unvirt/TerminalHelper.hpp @@ -1,7 +1,8 @@ #pragma once -namespace Unvirt{ - namespace TerminalHelper { +#include + +namespace Unvirt::TerminalHelper { #define UNVIRT_REMOVE_PARENS_IMPL(...) __VA_ARGS__ #define UNVIRT_REMOVE_PARENS(T) UNVIRT_REMOVE_PARENS_IMPL T @@ -46,8 +47,8 @@ namespace Unvirt{ #define UNVIRT_TERMCOL_LIGHT_CYAN(T) "\033[96m" UNVIRT_REMOVE_PARENS(T) "\033[0m" #define UNVIRT_TERMCOL_LIGHT_WHITE(T) "\033[97m" UNVIRT_REMOVE_PARENS(T) "\033[0m" - bool EnsureTerminalColor(void); - bool EnsureTerminalEncoding(void); + bool EnsureTerminalColor(void); + bool EnsureTerminalEncoding(void); + void GetCmdLine(std::string&); - } } diff --git a/Unvirt/Unvirt.cpp b/Unvirt/Unvirt.cpp index c9c2f61..461ab31 100644 --- a/Unvirt/Unvirt.cpp +++ b/Unvirt/Unvirt.cpp @@ -3,15 +3,32 @@ #include "StructFormatter.hpp" #include "CmdHelper.hpp" -#include "CKMinContext.hpp" -#include "CKFile.hpp" +#include +#include +#include #include #include +namespace Unvirt { + + class UnvirtContext { + public: + UnvirtContext() {} + ~UnvirtContext() {} + + void Run() { + Unvirt::TerminalHelper::EnsureTerminalColor(); + Unvirt::TerminalHelper::EnsureTerminalEncoding(); + + } + private: + + }; + +} + int main(int argc, char* argv[]) { - Unvirt::TerminalHelper::EnsureTerminalColor(); - Unvirt::TerminalHelper::EnsureTerminalEncoding(); //LibCmo::CK2::CKMinContext vtctx; //vtctx.SetTempPath("Temp"); @@ -23,9 +40,8 @@ int main(int argc, char* argv[]) { //if (doc) // Unvirt::StructFormatter::PrintCKFileInfo(doc->m_FileInfo); - auto cmd = new Unvirt::CmdHelper::InteractiveCmd(); - cmd->Run(); - delete cmd; + Unvirt::UnvirtContext ctx; + ctx.Run(); return 0; }