refactor: change repo layout

Assets/CodeGen/BMapBindings/.gitignore

@@ -0,0 +1,182 @@
+# ===== Result =====
+dest/*
+!dest/*.gitkeep
+
+# ===== Antlr =====
+*.interp
+*.tokens
+
+ExpFctsLexer*.java
+ExpFctsParser*.java
+
+# ===== Python =====
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# ===== Eclipse =====
+# Eclipse projects
+.classpath
+.project
+.settings/
+.metadata
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*

Assets/CodeGen/BMapBindings/CSharpWriter.java

@@ -0,0 +1,286 @@
+import java.io.OutputStreamWriter;
+import java.util.Vector;
+import java.util.stream.Collectors;
+
+public class CSharpWriter {
+
+	/**
+	 * The class represent the C# type corresponding to extracted variable type.
+	 */
+	private static class CsInteropType {
+		public CsInteropType() {
+			mMarshalAs = null;
+			mCsType = null;
+		}
+
+		/**
+		 * The argument of MarshalAsAttribute constructor. In generation, this field
+		 * should be used like this: "[MarshalAs(THIS)]" (for parameter) or "[return:
+		 * MarshalAs(THIS)]" (for return value).
+		 */
+		public String mMarshalAs;
+		/**
+		 * The C# type used in interop function declaration for corresponding parameter.
+		 */
+		public String mCsType;
+	}
+
+	/**
+	 * C# specified function which get C# used interop MarshalAs constructor
+	 * arguments and C# type used in interop function declaration.
+	 * 
+	 * @param vt The instance of {@linkplain VariableType} for fetching interop
+	 *           type.
+	 * @return The corresponding interop type of given variable type.
+	 */
+	private static CsInteropType getCsInteropType(ExpFctParamDecl paramdecl) {
+		// get essential variable type properties first
+		VariableType vt = paramdecl.mVarType;
+		String vt_base_type = vt.getBaseType();
+		int vt_pointer_level = vt.getPointerLevel();
+
+		// create return value
+		CsInteropType ret = new CsInteropType();
+
+		// use "switch" to check variable type
+		switch (vt_base_type) {
+		case "CKSTRING":
+			// decide direction cookies
+			String direction_cookie = "";
+			if (paramdecl.mIsInput) {
+				direction_cookie = "In";
+			} else {
+				direction_cookie = "Out";
+			}
+			// only allow 0 and 1 pointer level for string.
+			switch (vt_pointer_level) {
+			case 0:
+				ret.mMarshalAs = "UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = \"" + direction_cookie + "\"";
+				// ret.mMarshalAs = "UnmanagedType.LPUTF8Str";
+				ret.mCsType = "string";
+				break;
+			case 1:
+				ret.mMarshalAs = "UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler), MarshalCookie = \"" + direction_cookie + "\"";
+				ret.mCsType = "string[]";
+				break;
+			}
+			break;
+		case "CKDWORD":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.U4";
+				ret.mCsType = "uint";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "CKWORD":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.U2";
+				ret.mCsType = "ushort";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "CKINT":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.I4";
+				ret.mCsType = "int";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "bool":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.U1";
+				ret.mCsType = "bool";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "CKFLOAT":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.R4";
+				ret.mCsType = "float";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "CKBYTE":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.U1";
+				ret.mCsType = "byte";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "CK_ID":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.U4";
+				ret.mCsType = "uint";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "NakedOutputCallback":
+			// callback actually is a function pointer
+			// so it only allow base type without any pointer level.
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.FunctionPtr";
+				ret.mCsType = "OutputCallback";
+			}
+			break;
+		case "BMFile":
+			// In any case, BMFile only should be raw pointer
+			if (vt_pointer_level != 0) {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "BMMeshTransition":
+			// In any case, BMMeshTransition only should be raw pointer
+			if (vt_pointer_level != 0) {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "VxVector3":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.Struct";
+				ret.mCsType = "VxVector3";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "VxVector2":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.Struct";
+				ret.mCsType = "VxVector2";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "VxColor":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.Struct";
+				ret.mCsType = "VxColor";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "VxMatrix":
+			if (vt_pointer_level == 0) {
+				ret.mMarshalAs = "UnmanagedType.Struct";
+				ret.mCsType = "VxMatrix";
+			} else {
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		case "CK_TEXTURE_SAVEOPTIONS":
+		case "VX_PIXELFORMAT":
+		case "VXLIGHT_TYPE":
+		case "VXTEXTURE_BLENDMODE":
+		case "VXTEXTURE_FILTERMODE":
+		case "VXTEXTURE_ADDRESSMODE":
+		case "VXBLEND_MODE":
+		case "VXFILL_MODE":
+		case "VXSHADE_MODE":
+		case "VXCMPFUNC":
+		case "VXMESH_LITMODE":
+			// all enum type use the same strategy
+			if (vt_pointer_level == 0) {
+				// all enum type should be marshaled as its underlying type
+				// but we can use its name in C# directly.
+				ret.mMarshalAs = "UnmanagedType.U4";
+				ret.mCsType = vt_base_type;
+			} else {
+				// for pointer type, use IntPtr instead.
+				ret.mMarshalAs = "UnmanagedType.SysInt";
+				ret.mCsType = "IntPtr";
+			}
+			break;
+		}
+
+		// check whether we successfully get result
+		if (ret.mMarshalAs == null || ret.mCsType == null) {
+			throw new IllegalArgumentException("Unexpected type: " + vt.toCType());
+		}
+
+		// return value
+		return ret;
+	}
+
+	public static void writeCSharpCode(Vector<ExpFctDecl> data) throws Exception {
+		OutputStreamWriter writer = CommonHelper.openWriter("dest/BMExports.cs");
+		IndentHelper helper = new IndentHelper(writer);
+
+		// write function decls
+		for (ExpFctDecl fctdecl : data) {
+			// write annotation
+			// summary (just plain function name)
+			helper.printf("/// <summary>%s</summary>", fctdecl.mFctName);
+			// parameter list
+			for (ExpFctParamDecl paramdecl : fctdecl.mFctParams) {
+				helper.printf("/// <param name=\"%s\">Type: %s. %s%s</param>", paramdecl.mVarName,
+						paramdecl.mVarType.toCType(), (paramdecl.mIsInput ? "" : "This is OUT parameter. "),
+						paramdecl.mVarDesc);
+			}
+			// return value
+			helper.puts("/// <returns>True if no error, otherwise False.</returns>");
+
+			// write real function declaration
+			// first, write DllImportAttribute
+			helper.printf(
+					"[DllImport(g_DllName, EntryPoint = \"%s\", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]",
+					fctdecl.mFctName);
+			// second, write return value MarshalAsAttribute
+			helper.printf("[return: MarshalAs(UnmanagedType.U1)]");
+			// then, before we write function body, we need origanize its parameter list
+			// first
+			Vector<String> cs_param_list = new Vector<String>();
+			for (ExpFctParamDecl paramdecl : fctdecl.mFctParams) {
+				// create string builder
+				StringBuilder sb = new StringBuilder();
+				// push in out symbol
+				if (paramdecl.mIsInput) {
+					sb.append("[In, ");
+				} else {
+					sb.append("[Out, ");
+				}
+				// get interop type now
+				CsInteropType interop_type = getCsInteropType(paramdecl);
+				// push MarshalAsAttribute
+				sb.append("MarshalAs(");
+				sb.append(interop_type.mMarshalAs);
+				sb.append(")] ");
+				// push out keyword if parameter is out parameter
+				if (!paramdecl.mIsInput) {
+					sb.append("out ");
+				}
+				// push parameter cs type
+				sb.append(interop_type.mCsType);
+				sb.append(" ");
+				// push parameter name
+				sb.append(paramdecl.mVarName);
+				// insert built string into list
+				cs_param_list.add(sb.toString());
+			}
+			// join built parameter list and output real function declaration
+			helper.printf("internal static extern bool %s(%s);", fctdecl.mFctName,
+					cs_param_list.stream().collect(Collectors.joining(", ")));
+		}
+
+		writer.close();
+	}
+
+}

Assets/CodeGen/BMapBindings/CommonHelper.java

@@ -0,0 +1,31 @@
+//import java.io.FileInputStream;
+import java.io.FileOutputStream;
+//import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+
+public class CommonHelper {
+
+//	public static InputStreamReader openReader(String filename) throws Exception {
+//		FileInputStream fs = new FileInputStream(filename);
+//		return new InputStreamReader(fs, StandardCharsets.UTF_8);
+//	}
+
+	public static OutputStreamWriter openWriter(String filename) throws Exception {
+		FileOutputStream fs = new FileOutputStream(filename);
+		return new OutputStreamWriter(fs, StandardCharsets.UTF_8);
+	}
+
+//	public static void writeSnippet(OutputStreamWriter writer, String snippet_path) throws Exception {
+//		// open snippet
+//		InputStreamReader reader = openReader(snippet_path);
+//		// write into writer
+//		reader.transferTo(writer);
+//		reader.close();
+//	}
+	
+	public static String getDoxygenInOutStr(boolean isInput) {
+		return isInput ? "in" : "out";
+	}
+
+}

Assets/CodeGen/BMapBindings/ExpFctDecl.java

@@ -0,0 +1,29 @@
+import java.util.Vector;
+
+/**
+ * The class represent an export BMap function.
+ */
+public class ExpFctDecl {
+
+	/**
+	 * The name of this function.
+	 */
+	public String mFctName;
+	/**
+	 * The return value type of this function.
+	 */
+	public VariableType mFctRetType;
+	/**
+	 * The parameters (arguments) list of this function. Each items are
+	 * {@linkplain ExpFctParamDecl} and represent parameter one by one from left to
+	 * right.
+	 */
+	public Vector<ExpFctParamDecl> mFctParams;
+
+	public ExpFctDecl() {
+		mFctName = "";
+		mFctRetType = new VariableType();
+		mFctParams = new Vector<ExpFctParamDecl>();
+	}
+
+}

Assets/CodeGen/BMapBindings/ExpFctParamDecl.java

@@ -0,0 +1,48 @@
+
+/**
+ * The class represent a single parameter (argument) of function. This class
+ * usually is the member of {@linkplain ExpFctDecl}.
+ */
+public class ExpFctParamDecl {
+
+	/**
+	 * The type of this parameter.
+	 */
+	public VariableType mVarType;
+	/**
+	 * The name of this parameter.
+	 */
+	public String mVarName;
+	/**
+	 * True if this paramter is marked as input parameter, otherwise false.
+	 * <p>
+	 * Input parameter and output paramter is commonly used in C/C++ code. By using
+	 * this feature, each function can receive multiple arguments and return
+	 * multiple arguments without defining a struct to hold it.
+	 * <p>
+	 * The type of input parameter is itself. However, the type of output parameter
+	 * is the pointer of itself. So you may need get its pointer type when
+	 * processing output paramter, especially for the scenario that the target
+	 * language do not support explicit output parameter keyword.
+	 */
+	public boolean mIsInput;
+	/**
+	 * The description of this parameter.
+	 * <p>
+	 * This description is generated by this program. It will indicate the
+	 * underlying C++ type to tell end user how to treat this paramter because some
+	 * target languages' native calling style can not represent these detail.
+	 * <p>
+	 * In this program, this field must be written as a annotation of corresponding
+	 * function.
+	 */
+	public String mVarDesc;
+
+	public ExpFctParamDecl() {
+		mVarType = new VariableType();
+		mVarName = "";
+		mVarDesc = "";
+		mIsInput = true;
+	}
+
+}

Assets/CodeGen/BMapBindings/ExpFctsLexer.g4

@@ -0,0 +1,23 @@
+lexer grammar ExpFctsLexer;
+
+// keywords
+EXPFCTS_EXPORT: 'BMAP_EXPORT' ;
+EXPFCTS_FILE_DECL: 'BMPARAM_FILE_DECL' ;
+EXPFCTS_MESHTRANS_DECL: 'BMPARAM_MESHTRANS_DECL' ;
+EXPFCTS_OBJECT_DECL: 'BMPARAM_OBJECT_DECL' ;
+EXPFCTS_PARAM_IN: 'BMPARAM_IN' ;
+EXPFCTS_PARAM_OUT: 'BMPARAM_OUT' ;
+
+// symbols
+EXPFCTS_LPARENTHESES: '(' ;
+EXPFCTS_RPARENTHESES: ')' ;
+EXPFCTS_COMMA: ',' ;
+EXPFCTS_SEMICOLON: ';' ;
+EXPFCTS_STAR: '*' ;
+EXPFCTS_DOUBLE_COLON: '::' ;
+
+// identifider
+EXPFCTS_IDENTIFIER: [_a-zA-Z][_a-zA-Z0-9]* ;
+
+// remove whitespace and line break
+EXPFCTS_WS: [ \t\n\r\f]+ -> skip ;

Assets/CodeGen/BMapBindings/ExpFctsParser.g4

@@ -0,0 +1,21 @@
+parser grammar ExpFctsParser;
+options { tokenVocab = ExpFctsLexer; }
+
+program: fctDecl* ;
+
+fctDecl
+    : EXPFCTS_EXPORT varType EXPFCTS_IDENTIFIER '(' (fctArg (',' fctArg)*)? ')' ';'
+    ;
+
+fctArg
+    : EXPFCTS_FILE_DECL '(' EXPFCTS_IDENTIFIER ')' # fctArgFileDecl
+    | EXPFCTS_MESHTRANS_DECL '(' EXPFCTS_IDENTIFIER ')' #fctArgMeshTransDecl
+    | EXPFCTS_OBJECT_DECL '(' EXPFCTS_IDENTIFIER ',' EXPFCTS_IDENTIFIER ')' # fctArgObjDecl
+    | EXPFCTS_PARAM_IN '(' varType ',' EXPFCTS_IDENTIFIER ')' # fctArgParamIn
+    | EXPFCTS_PARAM_OUT '(' varType ',' EXPFCTS_IDENTIFIER ')' # fctArgParamOut
+    ;
+
+varType
+    : EXPFCTS_IDENTIFIER ('::' EXPFCTS_IDENTIFIER)* '*'* 
+    ;
+

Assets/CodeGen/BMapBindings/ExpFctsWalker.java

@@ -0,0 +1,134 @@
+import java.util.Collections;
+import java.util.Vector;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+public class ExpFctsWalker extends ExpFctsParserBaseListener {
+
+	public ExpFctsWalker() {
+		mFctList = new Vector<ExpFctDecl>();
+		mCurrentFct = null;
+		mCurrentParam = null;
+	}
+
+	public Vector<ExpFctDecl> getResult() {
+		return mFctList;
+	}
+
+	private Vector<ExpFctDecl> mFctList;
+	private ExpFctDecl mCurrentFct;
+	private ExpFctParamDecl mCurrentParam;
+
+	@Override
+	public void enterProgram(ExpFctsParser.ProgramContext ctx) {
+		mFctList.clear();
+	}
+
+	@Override
+	public void enterFctDecl(ExpFctsParser.FctDeclContext ctx) {
+		mCurrentFct = new ExpFctDecl();
+	}
+
+	@Override
+	public void exitFctDecl(ExpFctsParser.FctDeclContext ctx) {
+		// set name
+		mCurrentFct.mFctName = ctx.EXPFCTS_IDENTIFIER().getText();
+		// check return type
+		if (!mCurrentFct.mFctRetType.isValid() || mCurrentFct.mFctRetType.isPointer()
+				|| !mCurrentFct.mFctRetType.getBaseType().equals("bool"))
+			throw new IllegalArgumentException("invalid interface function return type. must be bool.");
+		
+		// add into list
+		mFctList.add(mCurrentFct);
+		mCurrentFct = null;
+	}
+
+	@Override
+	public void exitFctArgFileDecl(ExpFctsParser.FctArgFileDeclContext ctx) {
+		ExpFctParamDecl decl = new ExpFctParamDecl();
+		decl.mVarName = ctx.EXPFCTS_IDENTIFIER().getText();
+		decl.mVarDesc = "The pointer to corresponding BMFile.";
+		decl.mIsInput = true;
+		decl.mVarType.fromCType("BMap::BMFile*");
+		mCurrentFct.mFctParams.add(decl);
+	}
+
+	@Override
+	public void exitFctArgMeshTransDecl(ExpFctsParser.FctArgMeshTransDeclContext ctx) {
+		ExpFctParamDecl decl = new ExpFctParamDecl();
+		decl.mVarName = ctx.EXPFCTS_IDENTIFIER().getText();
+		decl.mVarDesc = "The pointer to corresponding BMMeshTransition.";
+		decl.mIsInput = true;
+		decl.mVarType.fromCType("BMap::BMMeshTransition*");
+		mCurrentFct.mFctParams.add(decl);
+	}
+
+	@Override
+	public void exitFctArgObjDecl(ExpFctsParser.FctArgObjDeclContext ctx) {
+		ExpFctParamDecl first_decl = new ExpFctParamDecl();
+		first_decl.mVarName = ctx.EXPFCTS_IDENTIFIER(0).getText();
+		first_decl.mVarDesc = "The pointer to corresponding BMFile.";
+		first_decl.mIsInput = true;
+		first_decl.mVarType.fromCType("BMap::BMFile*");
+		mCurrentFct.mFctParams.add(first_decl);
+
+		ExpFctParamDecl second_decl = new ExpFctParamDecl();
+		second_decl.mVarName = ctx.EXPFCTS_IDENTIFIER(1).getText();
+		second_decl.mVarDesc = "The CKID of object you accessing.";
+		second_decl.mIsInput = true;
+		second_decl.mVarType.fromCType("LibCmo::CK2::CK_ID");
+		mCurrentFct.mFctParams.add(second_decl);
+	}
+
+	@Override
+	public void enterFctArgParamIn(ExpFctsParser.FctArgParamInContext ctx) {
+		mCurrentParam = new ExpFctParamDecl();
+	}
+
+	@Override
+	public void exitFctArgParamIn(ExpFctsParser.FctArgParamInContext ctx) {
+		mCurrentParam.mVarName = ctx.EXPFCTS_IDENTIFIER().getText();
+		mCurrentParam.mIsInput = true;
+
+		mCurrentFct.mFctParams.add(mCurrentParam);
+		mCurrentParam = null;
+	}
+
+	@Override
+	public void enterFctArgParamOut(ExpFctsParser.FctArgParamOutContext ctx) {
+		mCurrentParam = new ExpFctParamDecl();
+	}
+
+	@Override
+	public void exitFctArgParamOut(ExpFctsParser.FctArgParamOutContext ctx) {
+		mCurrentParam.mVarName = ctx.EXPFCTS_IDENTIFIER().getText();
+		mCurrentParam.mIsInput = false;
+		// set to its pointer type
+		// mCurrentParam.mVarType = mCurrentParam.mVarType.getPointerOfThis();
+
+		mCurrentFct.mFctParams.add(mCurrentParam);
+		mCurrentParam = null;
+	}
+
+	@Override
+	public void exitVarType(ExpFctsParser.VarTypeContext ctx) {
+		// get namespace parts and join them
+		String ctype = ctx.EXPFCTS_IDENTIFIER().stream().map(value -> value.getText())
+				.collect(Collectors.joining("::"));
+		// add star if necessary
+		if (ctx.EXPFCTS_STAR() != null) {
+			ctype += String.join("", Collections.nCopies(ctx.EXPFCTS_STAR().size(), "*"));
+		}
+
+		if (!mCurrentFct.mFctRetType.isValid()) {
+			// fill function ret type first
+			mCurrentFct.mFctRetType.fromCType(ctype);
+		} else {
+			// otherwise, fill param data
+			mCurrentParam.mVarType.fromCType(ctype);
+		}
+	}
+
+}

Assets/CodeGen/BMapBindings/ExtractBMapFctDecl.py

@@ -0,0 +1,19 @@
+import os, re
+
+self_path: str = os.path.dirname(__file__)
+src_file: str = os.path.join(self_path, '../../BMap/BMExports.hpp')
+dst_file: str = os.path.join(self_path, 'dest/BMExports.hpp')
+
+with open(src_file, 'r', encoding='utf-8') as fsrc:
+    # read full text
+    fulltext: str = fsrc.read()
+    # do findall and write into file
+    with open(dst_file, 'w', encoding='utf-8') as fdst:
+        # We should not only match BMAP_EXPORT,
+        # because it may match the defination of BMAP_EXPORT.
+        # So we add a bool at head because all BMap functions return bool.
+        for item in re.findall('^BMAP_EXPORT[ \\t]+bool[ \\t]+[^;]+;', fulltext, re.MULTILINE):
+            fdst.write(item)
+            fdst.write('\n')
+
+print('DONE')

Assets/CodeGen/BMapBindings/IndentHelper.java

@@ -0,0 +1,42 @@
+import java.io.OutputStreamWriter;
+
+public class IndentHelper {
+	public IndentHelper(OutputStreamWriter writer) {
+		mIndent = 0;
+		mWriter = writer;
+	}
+
+	private int mIndent;
+	private OutputStreamWriter mWriter;
+
+	public void inc() {
+		++mIndent;
+	}
+
+	public void dec() {
+		--mIndent;
+	}
+
+	private void indent() throws Exception {
+		for (int i = 0; i < mIndent; ++i) {
+			mWriter.write("    ");
+		}
+	}
+	
+	private void lineBreak() throws Exception {
+		mWriter.write(System.lineSeparator());
+	}
+
+	public void puts(String data) throws Exception {
+		indent();
+		mWriter.write(data);
+		lineBreak();
+	}
+
+	public void printf(String fmt, Object... args) throws Exception {
+		indent();
+		mWriter.write(String.format(fmt, args));
+		lineBreak();
+	}
+
+}

Assets/CodeGen/BMapBindings/JsonWriter.java

@@ -0,0 +1,60 @@
+import java.io.OutputStreamWriter;
+import java.util.Vector;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class JsonWriter {
+	
+	private static JsonObject writeVariableType(VariableType vt) {
+		JsonObject data = new JsonObject();
+		
+		JsonArray hierarchy = new JsonArray();
+		for (String item : vt.getBaseTypeHierarchy()) {
+			hierarchy.add(item);
+		}
+		data.add("hierarchy", hierarchy);
+		data.addProperty("pointer_level", vt.getPointerLevel());
+		
+		return data;
+	}
+	
+	private static JsonObject writeExpFctParamDecl(ExpFctParamDecl paramdecl) {
+		JsonObject data = new JsonObject();
+		data.addProperty("name", paramdecl.mVarName);
+		data.addProperty("is_input", paramdecl.mIsInput);
+		data.addProperty("desc", paramdecl.mVarDesc);
+		data.add("type", writeVariableType(paramdecl.mVarType));
+		
+		return data;
+	}
+	
+	private static JsonObject writeExpFctDecl(ExpFctDecl fctdecl) {
+		JsonObject data = new JsonObject();
+		data.addProperty("name", fctdecl.mFctName);
+		data.add("return", writeVariableType(fctdecl.mFctRetType));
+		
+		JsonArray paramlist = new JsonArray();
+		for (ExpFctParamDecl paramdecl : fctdecl.mFctParams) {
+			paramlist.add(writeExpFctParamDecl(paramdecl));
+		}
+		data.add("params", paramlist);
+		
+		return data;
+	}
+	
+	public static void writeJson(Vector<ExpFctDecl> data) throws Exception {
+		OutputStreamWriter writer = CommonHelper.openWriter("dest/BMExports.json");
+		//Gson gson_instance = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
+		Gson gson_instance = new GsonBuilder().disableHtmlEscaping().create();
+		
+		JsonArray fcts = new JsonArray();
+		for (ExpFctDecl fctdecl : data) {
+			fcts.add(writeExpFctDecl(fctdecl));
+		}
+		
+		writer.write(gson_instance.toJson(fcts));
+		writer.close();
+	}
+}

Assets/CodeGen/BMapBindings/MainRunner.java

@@ -0,0 +1,34 @@
+import java.io.FileInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Vector;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+public class MainRunner {
+
+	public static void main(String[] args) throws Exception {
+		// get interface structure
+		FileInputStream fs = new FileInputStream("dest/BMExports.hpp");
+		CharStream antlrfs = CharStreams.fromStream(fs, StandardCharsets.UTF_8);
+		ExpFctsLexer lexer = new ExpFctsLexer(antlrfs);
+		CommonTokenStream tokens = new CommonTokenStream(lexer);
+		ExpFctsParser parser = new ExpFctsParser(tokens);
+
+		// parsing data
+		ParseTree tree = parser.program();
+		ParseTreeWalker walker = new ParseTreeWalker();
+		ExpFctsWalker worker = new ExpFctsWalker();
+		walker.walk(worker, tree);
+		fs.close();
+
+		// get data and write them
+		Vector<ExpFctDecl> result = worker.getResult();
+		PythonWriter.writePythonCode(result);
+		CSharpWriter.writeCSharpCode(result);
+		JsonWriter.writeJson(result);
+		
+		// print message.
+		System.out.println("DONE!");
+	}
+}

Assets/CodeGen/BMapBindings/PythonWriter.java

@@ -0,0 +1,96 @@
+import java.io.OutputStreamWriter;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
+import java.util.stream.Collectors;
+
+public class PythonWriter {
+
+	private static final Map<String, String> g_CppTypeMap = cppTypeMapCreator();
+
+	private static Map<String, String> cppTypeMapCreator() {
+		Map<String, String> cache = new HashMap<String, String>();
+		cache.put("CKSTRING", "CKSTRING");
+		cache.put("CKDWORD", "CKDWORD");
+		cache.put("CKWORD", "CKWORD");
+		cache.put("CKINT", "CKINT");
+		cache.put("bool", "bool");
+		cache.put("CKFLOAT", "CKFLOAT");
+		cache.put("CKBYTE", "CKBYTE");
+		cache.put("CK_ID", "CKID");
+		cache.put("NakedOutputCallback", "callback");
+		cache.put("BMFile", "void");
+		cache.put("BMMeshTransition", "void");
+		cache.put("VxVector3", "VxVector3");
+		cache.put("VxVector2", "VxVector2");
+		cache.put("VxColor", "VxColor");
+		cache.put("VxMatrix", "VxMatrix");
+		cache.put("CK_TEXTURE_SAVEOPTIONS", "enum");
+		cache.put("VX_PIXELFORMAT", "enum");
+		cache.put("VXLIGHT_TYPE", "enum");
+		cache.put("VXTEXTURE_BLENDMODE", "enum");
+		cache.put("VXTEXTURE_FILTERMODE", "enum");
+		cache.put("VXTEXTURE_ADDRESSMODE", "enum");
+		cache.put("VXBLEND_MODE", "enum");
+		cache.put("VXFILL_MODE", "enum");
+		cache.put("VXSHADE_MODE", "enum");
+		cache.put("VXCMPFUNC", "enum");
+		cache.put("VXMESH_LITMODE", "enum");
+		return Collections.unmodifiableMap(cache);
+	}
+
+	private static String pythonTypeGetter(ExpFctParamDecl paramdecl) throws IllegalArgumentException {
+		VariableType vt = paramdecl.mVarType;
+		if (!paramdecl.mIsInput) {
+			vt = vt.getPointerOfThis();
+		}
+
+		// create string builder for build final type string
+		StringBuilder sb = new StringBuilder();
+		// add type prefix
+		sb.append("bm_");
+		// try getting cpp type from base type
+		String cpp_type = g_CppTypeMap.get(vt.getBaseType());
+		if (cpp_type == null) {
+			throw new IllegalArgumentException("Unexpected type: " + vt.toCType());
+		}
+		// assign cpp type
+		sb.append(cpp_type);
+		// add pointer suffix
+		if (vt.isPointer()) {
+			sb.append("_");
+			sb.append(String.join("", Collections.nCopies(vt.getPointerLevel(), "p")));
+		}
+		// return built type string.
+		return sb.toString();
+	}
+
+	public static void writePythonCode(Vector<ExpFctDecl> data) throws Exception {
+		OutputStreamWriter writer = CommonHelper.openWriter("dest/BMExports.py");
+		IndentHelper helper = new IndentHelper(writer);
+
+		// write function decls
+		for (ExpFctDecl fctdecl : data) {
+			// write annotation
+			// function name
+			helper.printf("## %s", fctdecl.mFctName);
+			// param
+			for (ExpFctParamDecl paramdecl : fctdecl.mFctParams) {
+				helper.printf("#  @param %s[%s] Type: %s. %s%s", paramdecl.mVarName,
+						CommonHelper.getDoxygenInOutStr(paramdecl.mIsInput), paramdecl.mVarType.toCType(),
+						(paramdecl.mIsInput ? "" : "Use ctypes.byref(data) pass it. "), paramdecl.mVarDesc);
+			}
+			// return val
+			helper.puts("#  @return True if no error, otherwise False.");
+
+			// write real declaration
+			// first, we need join all param
+			helper.printf("%s = _create_bmap_func('%s', [%s])", fctdecl.mFctName, fctdecl.mFctName, fctdecl.mFctParams
+					.stream().map(value -> pythonTypeGetter(value)).collect(Collectors.joining(", ")));
+		}
+
+		writer.close();
+	}
+
+}

Assets/CodeGen/BMapBindings/README.md

@@ -0,0 +1,17 @@
+# BMap Bindings Generation
+
+A helper program to generate BMap binding in Python and CSharp
+
+This program is consisted by 2 parts, first is Python part which extract BMap interface function declarations from source file, thus following Antlr step can focus on syntax analyze.  
+Next part is Antlr part. It analyse extracted function declarations and output corresponding Python binding and CSharp binding.
+
+```
+python ExtractBMapFctDecl.py
+
+antlr4 ExpFctsLexer.g4
+antlr4 ExpFctsParser.g4
+
+javac *.java
+java MainRunner
+```
+

Assets/CodeGen/BMapBindings/VariableType.java

@@ -0,0 +1,153 @@
+import java.util.Collections;
+import java.util.Vector;
+import java.util.stream.Collectors;
+
+/**
+ * The class represent the type of each parameters and function return value.
+ */
+public class VariableType {
+	/**
+	 * The base type of this variable removing all ending stars (remove all pointer
+	 * levels) Each item in this a part of namespace and the last one must be the
+	 * type itself (without any namespace restriction). If no namespace restriction
+	 * for this type, this Vector will only have one item.
+	 * <p>
+	 * For end user, it is enough that knowing the last item is type itself.
+	 */
+	private Vector<String> mBaseType;
+	/**
+	 * The pointer level of this type. It is equal to the count of trailing star of
+	 * this field in C style representation.
+	 */
+	private int mPointerLevel;
+
+	/**
+	 * Construct an empty varible type. This is commonly used constructor.
+	 */
+	public VariableType() {
+		mBaseType = new Vector<String>();
+		mPointerLevel = 0;
+	}
+
+	/**
+	 * The constructor used for cloning self. This constructor is only can be used
+	 * by self.
+	 * 
+	 * @param base_type     The hierarchy of the variable type.
+	 * @param pointer_level The pointer level of new created variable type.
+	 */
+	private VariableType(Vector<String> base_type, int pointer_level) {
+		mBaseType = (Vector<String>) base_type.clone();
+		mPointerLevel = pointer_level;
+	}
+
+	/**
+	 * Set this variable type with a type string in C/C++ style. For example
+	 * "NSTest::NSTest2::MyType**".
+	 * 
+	 * @param ctype The type string in C/C++ style.
+	 */
+	public void fromCType(String ctype) {
+		if (ctype.isEmpty())
+			throw new IllegalArgumentException("empty string can not be parsed.");
+
+		// get pointer part and name part
+		int len = ctype.length();
+		int star_pos = ctype.indexOf('*');
+		String namepart;
+		if (star_pos == -1) {
+			// no star
+			namepart = ctype;
+			mPointerLevel = 0;
+		} else {
+			// has star
+			if (star_pos == 0)
+				throw new IllegalArgumentException("base type not found.");
+			namepart = ctype.substring(0, star_pos);
+			mPointerLevel = len - star_pos;
+		}
+
+		// resolve name part
+		mBaseType.clear();
+		for (String item : namepart.split("::")) {
+			mBaseType.add(item);
+		}
+	}
+
+	/**
+	 * Build a type string represented by this variable type in C/C++ style.
+	 * 
+	 * @return The type string in C/C++ style.
+	 */
+	public String toCType() {
+		return mBaseType.stream().collect(Collectors.joining("::"))
+				+ String.join("", Collections.nCopies(mPointerLevel, "*"));
+	}
+
+	/**
+	 * Get the base type of this variable type without any namespace. It just simply
+	 * get the last entry in type hierarchy.
+	 * 
+	 * @return The base type string without namespace prefix.
+	 */
+	public String getBaseType() {
+		return mBaseType.lastElement();
+	}
+
+	/**
+	 * Check whether this variable type is a pointer. This function just check
+	 * whether the pointer level of this variavle type is zero.
+	 * 
+	 * @return True if it is pointer, otherwise false.
+	 */
+	public boolean isPointer() {
+		return mPointerLevel != 0;
+	}
+
+	/**
+	 * Return the pointer level of this variable type. You can simply assume the
+	 * pointer level is equal to the count of trailing star.
+	 * 
+	 * @return The pointer level integer. Zero means that this type is not a
+	 *         pointer.
+	 */
+	public int getPointerLevel() {
+		return mPointerLevel;
+	}
+
+	/**
+	 * Return the clone of the type hierarchy of this variable type.
+	 * <p>
+	 * It is rarely used. This only should be used when you need the namespace
+	 * hierarchy of this variable type.
+	 * 
+	 * @return The clone of current variable type hierarchy.
+	 */
+	public Vector<String> getBaseTypeHierarchy() {
+		return (Vector<String>) mBaseType.clone();
+	}
+
+	/**
+	 * Check whether this type is a valid one. It actually check whether type
+	 * hierarchy include at least one entry.
+	 * 
+	 * @return True if no problem of this type, otherwise false.
+	 */
+	public boolean isValid() {
+		return mBaseType.size() != 0;
+	}
+
+	/**
+	 * Return a new created variable type which is the pointer of this variable
+	 * type.
+	 * <p>
+	 * In internal implementation, it just create a clone of current variable type
+	 * with the increase of pointer level by 1.
+	 * 
+	 * @return The new created pointer type of this variable type.
+	 */
+	public VariableType getPointerOfThis() {
+		return new VariableType(mBaseType, mPointerLevel + 1);
+	}
+
+}

Assets/CodeGen/EnumsMigration/.gitignore

@@ -0,0 +1,43 @@
+# ===== Result =====
+dest/*
+!dest/*.gitkeep
+
+# ===== ANTLR Output =====
+*.interp
+*.tokens
+
+CKGeneralLexer*.java
+CKEnumsParser*.java
+CKDefinesParser*.java
+
+# ===== Eclipse Java =====
+# Eclipse projects
+.classpath
+.project
+.settings/
+.metadata
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*

Assets/CodeGen/EnumsMigration/CKDefinesParser.g4

@@ -0,0 +1,6 @@
+parser grammar CKDefinesParser;
+options { tokenVocab = CKGeneralLexer; }
+
+prog: definePair+ ;
+
+definePair: CKGENERAL_DEFINE CKGENERAL_ID (CKGENERAL_NUM | CKGENERAL_ID) ;

Assets/CodeGen/EnumsMigration/CKEnumsParser.g4

@@ -0,0 +1,14 @@
+parser grammar CKEnumsParser;
+options { tokenVocab = CKGeneralLexer; }
+
+prog: enumBody* ;
+
+enumBody: CKGENERAL_TYPEDEF? CKGENERAL_ENUM CKGENERAL_ID CKGENERAL_LBRACKET 
+entryPair+
+CKGENERAL_RBRACKET CKGENERAL_ID? CKGENERAL_SEMICOLON ;
+
+entryPair: CKGENERAL_ID (CKGENERAL_EQUAL entryValue)? CKGENERAL_COMMA? ;
+
+entryValue: CKGENERAL_NUM (CKGENERAL_LSHIFT CKGENERAL_NUM)?     # entryDirectValue
+| CKGENERAL_ID (CKGENERAL_OR CKGENERAL_ID)*                         # entryRelativeValue
+;

Assets/CodeGen/EnumsMigration/CKGeneralLexer.g4

@@ -0,0 +1,26 @@
+lexer grammar CKGeneralLexer;
+
+channels { COMMENTS, WHITESPACE }
+
+// keywords
+CKGENERAL_TYPEDEF: 'typedef' ;
+CKGENERAL_DEFINE: '#define' ;
+CKGENERAL_ENUM: 'enum' ;
+// symbols
+CKGENERAL_LBRACKET: '{' ;
+CKGENERAL_RBRACKET: '}' ;
+CKGENERAL_EQUAL: '=';
+CKGENERAL_SEMICOLON: ';' ;
+CKGENERAL_LSHIFT: '<<' ;
+CKGENERAL_OR: '|' ;
+CKGENERAL_COMMA: ',' ;
+
+// identifider and number
+CKGENERAL_ID: [_a-zA-Z][_a-zA-Z0-9]* ;
+CKGENERAL_NUM: (('0'[xX]) | '-')? [0-9a-fA-F]+ [uUlL]* ;
+
+// comments
+CKGENERAL_LINE_COMMENT: '//' ~[\r\n]* -> channel(COMMENTS);
+CKGENERAL_BLOCK_COMMENT: '/*' .*? '*/' -> channel(COMMENTS);
+// whitespace
+CKGENERAL_WS: [ \t\r\n]+ -> channel(WHITESPACE);

Assets/CodeGen/EnumsMigration/CSharpWriter.java

@@ -0,0 +1,168 @@
+import java.io.OutputStreamWriter;
+
+/**
+ * Write enum declarations and accessible value into CSharp format.
+ */
+public class CSharpWriter {
+
+	// =========== C# Enum Declaration Writer ===========
+
+	/**
+	 * Get corredponding C# underlying type of given enum.
+	 * <p>
+	 * This is C# specific function.
+	 * 
+	 * @param canUnsigned The parameter stored in Enum_t that indicate whether this
+	 *                    enum can use unsigned int as its underlying type.
+	 * @return The string form of its underlying type.
+	 */
+	private static String getEnumUnderlyingType(boolean canUnsigned) {
+		return canUnsigned ? "uint" : "int";
+	}
+
+	/**
+	 * Internal real enum declaration writer.
+	 * 
+	 * @param writer {@linkplain java.io.OutputStreamWriter} instance for writing.
+	 * @param prog   {@linkplain EnumsHelper.EnumCollection_t} instance for writing.
+	 * @throws Exception
+	 */
+	private static void internalWriteEnums(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog)
+			throws Exception {
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.CSharp);
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum comment
+			indent.briefComment(enum_t.mEnumComment);
+
+			// write enum start
+			// write flasg attribute if it is
+			if (enum_t.mUseFlags) {
+				indent.puts("[Flags]");
+			}
+			indent.printf("public enum %s : %s {", enum_t.mEnumName, getEnumUnderlyingType(enum_t.mCanUnsigned));
+			indent.inc();
+
+			// write enum entries
+			for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
+				// write entry self
+				if (enumEntry_t.mEntryValue == null) {
+					indent.printf("%s,", enumEntry_t.mEntryName);
+				} else {
+					indent.printf("%s = %s,", enumEntry_t.mEntryName, enumEntry_t.mEntryValue);
+				}
+
+				// write entry comment after member
+				indent.afterMemberComment(enumEntry_t.mEntryComment);
+			}
+
+			// write enum tail
+			indent.dec();
+			indent.puts("}");
+		}
+	}
+
+	/**
+	 * Write an enum declaration collection into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum declaration collection writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param prog     {@linkplain EnumsHelper.EnumCollection_t} instance for
+	 *                 writing.
+	 * @throws Exception
+	 */
+	public static void writeEnums(String filename, EnumsHelper.EnumCollection_t prog) throws Exception {
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteEnums(fs, prog);
+		fs.close();
+	}
+
+	/**
+	 * Write a single enum declaration into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum declaration collection writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param _enum    {@linkplain EnumsHelper.Enum_t} instance for writing.
+	 * @throws Exception
+	 */
+	public static void writeEnum(String filename, EnumsHelper.Enum_t _enum) throws Exception {
+		// create collection from single enum
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteEnums(fs, col);
+		fs.close();
+	}
+
+	// =========== C# Enum Accessible Value Writer ===========
+
+	/**
+	 * Internal real enum accessible value writer.
+	 * 
+	 * @param writer {@linkplain java.io.OutputStreamWriter} instance for writing.
+	 * @param prog   {@linkplain EnumsHelper.EnumCollection_t} instance for writing.
+	 * @throws Exception
+	 */
+	private static void internalWriteAccVals(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog)
+			throws Exception {
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.CSharp);
+		// write enum collections
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum desc header
+			indent.printf(
+					"public static readonly System.Collections.Generic.Dictionary<%s, string> %s = new System.Collections.Generic.Dictionary<%s, string>() {",
+					enum_t.mEnumName, enum_t.mEnumName, enum_t.mEnumName);
+			indent.inc();
+
+			// write enum desc entries
+			for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
+				indent.printf("{ %s.%s, \"%s\" },", enum_t.mEnumName, enumEntry_t.mEntryName, enumEntry_t.mEntryName);
+			}
+
+			// write enum tail
+			indent.dec();
+			indent.puts("};");
+		}
+	}
+
+	/**
+	 * Write an enum accessible value collection into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum accessible value collection
+	 * writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param prog     {@linkplain EnumsHelper.EnumCollection_t} instance for
+	 *                 writing.
+	 * @throws Exception
+	 */
+	public static void writeAccVals(String filename, EnumsHelper.EnumCollection_t prog) throws Exception {
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteAccVals(fs, prog);
+		fs.close();
+	}
+
+	/**
+	 * Write a single enum accessible value into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum accessible value collection
+	 * writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param _enum    {@linkplain EnumsHelper.Enum_t} instance for writing.
+	 * @throws Exception
+	 */
+	public static void writeAccVal(String filename, EnumsHelper.Enum_t _enum) throws Exception {
+		// create a collection with single enum.
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteAccVals(fs, col);
+		fs.close();
+	}
+}

Assets/CodeGen/EnumsMigration/ClassidWalker.java

@@ -0,0 +1,120 @@
+
+import java.util.Stack;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+/**
+ * The specialized walker for collecting CK_CLASSID and its inherit
+ * relationship.
+ */
+public class ClassidWalker extends CKDefinesParserBaseListener {
+
+	public ClassidWalker(BufferedTokenStream tokenStream) {
+		mTokenStream = tokenStream;
+		mResult = null;
+
+		mLevelStack = null;
+		mCurrentEnum = null;
+		mCurrentEntry = null;
+	}
+
+	public EnumsHelper.Enum_t getEnum() {
+		return mResult;
+	}
+
+	private int getClassidLevel(Token defineHead) {
+		Token ws = CommonHelper.getPreChannelToken(mTokenStream, defineHead, CKGeneralLexer.WHITESPACE);
+		if (ws == null)
+			return 0;
+
+		// reverse finding how many tab used.
+		int counter = 0;
+		char[] wstxt = ws.getText().toCharArray();
+		for (int i = wstxt.length - 1; i >= 0; i--) {
+			if (wstxt[i] == '\t') {
+				counter++;
+			} else {
+				break;
+			}
+		}
+		return counter;
+	}
+
+	private void safePop() {
+		if (mLevelStack.size() != 0)
+			mLevelStack.pop();
+	}
+
+	private void safePopTimes(int times) {
+		for (int i = 0; i < times; i++) {
+			if (mLevelStack.size() != 0)
+				mLevelStack.pop();
+		}
+	}
+
+	private BufferedTokenStream mTokenStream;
+	private EnumsHelper.Enum_t mResult;
+
+	private int mLevel;
+	private Stack<EnumsHelper.EnumEntryWithHierarchy_t> mLevelStack;
+	private EnumsHelper.Enum_t mCurrentEnum;
+	private EnumsHelper.EnumEntryWithHierarchy_t mCurrentEntry;
+
+	@Override
+	public void enterProg(CKDefinesParser.ProgContext ctx) {
+		mLevel = 0;
+		mLevelStack = new Stack<EnumsHelper.EnumEntryWithHierarchy_t>();
+		mCurrentEnum = new EnumsHelper.Enum_t();
+	}
+
+	@Override
+	public void exitProg(CKDefinesParser.ProgContext ctx) {
+		mLevel = 0;
+		mLevelStack = null;
+
+		// classid is signed int and do not have flags feature.
+		mCurrentEnum.mCanUnsigned = false;
+		mCurrentEnum.mUseFlags = false;
+		mResult = mCurrentEnum;
+		mCurrentEnum = null;
+	}
+
+	@Override
+	public void enterDefinePair(CKDefinesParser.DefinePairContext ctx) {
+		mCurrentEntry = new EnumsHelper.EnumEntryWithHierarchy_t();
+	}
+
+	@Override
+	public void exitDefinePair(CKDefinesParser.DefinePairContext ctx) {
+		// fill entry info
+		mCurrentEntry.mEntryName = ctx.CKGENERAL_ID(0).getText();
+		mCurrentEntry.mEntryValue = ctx.CKGENERAL_NUM().getText();
+
+		// fill entry level info
+		int this_level = getClassidLevel(ctx.getStart());
+		if (this_level > mLevel) {
+			// level up
+			mLevel++;
+			
+			mLevelStack.push(mCurrentEntry);
+			mCurrentEntry.mHierarchy.addAll(mLevelStack);
+		} else if (this_level == mLevel) {
+			safePop();
+			mLevelStack.push(mCurrentEntry);
+			mCurrentEntry.mHierarchy.addAll(mLevelStack);
+		} else if (this_level < mLevel) {
+			// level down
+			safePopTimes(mLevel - this_level + 1);
+			mLevel = this_level;
+			
+			mLevelStack.push(mCurrentEntry);
+			mCurrentEntry.mHierarchy.addAll(mLevelStack);
+		}
+		
+		// move to list
+		mCurrentEnum.mEntries.add(mCurrentEntry);
+		mCurrentEntry = null;
+	}
+
+}

Assets/CodeGen/EnumsMigration/CommentsFinder.java

@@ -0,0 +1,51 @@
+import java.util.List;
+
+import org.antlr.v4.runtime.*;
+
+public class CommentsFinder {
+
+	enum CommentsPosition {
+		Unknown, Precomment, Postcomment
+	}
+
+	public CommentsFinder(BufferedTokenStream tokenStream) {
+		mTokenStream = tokenStream;
+		mCommentsPos = CommentsPosition.Unknown;
+	}
+
+	private BufferedTokenStream mTokenStream;
+	private CommentsPosition mCommentsPos;
+
+	public String getComment(Token preToken, Token postToken) {
+		switch (mCommentsPos) {
+		case Unknown: {
+			// if we don't know where is our token,
+			// we should assume it is from precomment to postcomment
+			// and check it.
+			List<Token> precomment = CommonHelper.getPreChannelTokens(mTokenStream, preToken, CKGeneralLexer.COMMENTS);
+			if (precomment != null) {
+				mCommentsPos = CommentsPosition.Precomment;
+				return CommonHelper.cutComments(precomment);
+			}
+			
+			List<Token> postcomment = CommonHelper.getPostChannelTokens(mTokenStream, postToken, CKGeneralLexer.COMMENTS);
+			if (postcomment != null) {
+				mCommentsPos = CommentsPosition.Postcomment;
+				return CommonHelper.cutComments(postcomment);
+			}
+			
+			// really do not have comment, return empty and keep comment pos
+			return null;
+		}
+		case Precomment: {
+			return CommonHelper.cutComments(CommonHelper.getPreChannelTokens(mTokenStream, preToken, CKGeneralLexer.COMMENTS));
+		}
+		case Postcomment: {
+			return CommonHelper.cutComments(CommonHelper.getPostChannelTokens(mTokenStream, postToken, CKGeneralLexer.COMMENTS));
+		}
+		default:
+			return null;
+		}
+	}
+
+}

Assets/CodeGen/EnumsMigration/CommonHelper.java

@@ -0,0 +1,237 @@
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.*;
+
+public class CommonHelper {
+
+	// =========== Token Finder & Comments Processing ===========
+
+	public static Token getPreChannelToken(BufferedTokenStream stream, Token token, int channel) {
+		List<Token> tokens = stream.getHiddenTokensToLeft(token.getTokenIndex(), channel);
+		if (tokens == null)
+			return null;
+		return tokens.get(0);
+	}
+
+	public static Token getPostChannelToken(BufferedTokenStream stream, Token token, int channel) {
+		List<Token> tokens = stream.getHiddenTokensToRight(token.getTokenIndex(), channel);
+		if (tokens == null)
+			return null;
+		return tokens.get(0);
+	}
+
+	public static List<Token> getPreChannelTokens(BufferedTokenStream stream, Token token, int channel) {
+		return stream.getHiddenTokensToLeft(token.getTokenIndex(), channel);
+	}
+
+	public static List<Token> getPostChannelTokens(BufferedTokenStream stream, Token token, int channel) {
+		return stream.getHiddenTokensToRight(token.getTokenIndex(), channel);
+	}
+
+	/**
+	 * Cut the head and tail of comment
+	 * 
+	 * @param comment The comment need to be cut.
+	 * @return The cut comment.
+	 */
+	public static String cutComment(Token comment) {
+		if (comment == null)
+			return null;
+
+		switch (comment.getType()) {
+		case CKGeneralLexer.CKGENERAL_LINE_COMMENT: {
+			return removeStars(comment.getText().substring(2));
+		}
+		case CKGeneralLexer.CKGENERAL_BLOCK_COMMENT: {
+			String cache = comment.getText();
+			return removeStars(cache.substring(2, cache.length() - 4));
+		}
+		default:
+			return comment.getText();
+		}
+	}
+
+	/**
+	 * Cut multiple comments.
+	 * <p>
+	 * Each comment will be cut the head and tail first. And strip all whitespace.
+	 * Then join together.
+	 * 
+	 * @param tokens Multiple comments.
+	 * @return The joined comment.
+	 */
+	public static String cutComments(List<Token> tokens) {
+		if (tokens == null)
+			return null;
+
+		return tokens.stream().map(value -> {
+			String text = cutComment(value).strip();
+			return text + " ";
+		}).collect(Collectors.joining(""));
+	}
+
+	// =========== Number Operations ===========
+
+	/**
+	 * Check whether Antlr captured CKGENERAL_NUM is a negative number.
+	 * 
+	 * @param numstr The captured number.
+	 * @return true if it is negative number.
+	 */
+	public static boolean isNegativeNumber(String numstr) {
+		return numstr.startsWith("-");
+	}
+
+	/**
+	 * Check whether Altlr captured CKGENERAL_NUM is a hex number.
+	 * 
+	 * @param numstr The captured number.
+	 * @return true if it is hex number.
+	 */
+	public static boolean isHexNumber(String numstr) {
+		return numstr.startsWith("0x") || numstr.startsWith("0X");
+	}
+	
+	/**
+	 * Convert accepted string into Python cupported format.
+	 * 
+	 * It actually just remove trail "UL".
+	 * 
+	 * @param numstr The captured number.
+	 * @return The Python style number string.
+	 */
+	public static String convertToPythonNumber(String numstr) {
+		return numstr.replaceFirst("[ulUL]+$", "");
+	}
+
+	// =========== Parts ===========
+
+	enum CKParts {
+		CK2, VxMath
+	}
+
+	enum LangType {
+		Cpp, Python, CSharp
+	}
+
+	public static String getCKPartsNamespace(CKParts parts) {
+		switch (parts) {
+		case CK2:
+			return "CK2";
+		case VxMath:
+			return "VxMath";
+		default:
+			throw new IllegalArgumentException("Unexpected value: " + parts);
+		}
+	}
+
+	// =========== File Operations ===========
+
+	public static class InputFilePair {
+		public CharStream mAntlrStream;
+		public FileInputStream mUnderlyingStream;
+	}
+
+	public static InputFilePair openInputFile(String filename) throws Exception {
+		InputFilePair pair = new InputFilePair();
+		pair.mUnderlyingStream = new FileInputStream(filename);
+		pair.mAntlrStream = CharStreams.fromStream(pair.mUnderlyingStream, StandardCharsets.UTF_8);
+		return pair;
+	}
+
+	/**
+	 * Get output file for writing.
+	 * 
+	 * @param filename The name of file opening.
+	 * @return An OutputStreamWriter.
+	 * @throws Exception
+	 */
+	public static OutputStreamWriter openOutputFile(String filename) throws Exception {
+		FileOutputStream fs = new FileOutputStream(filename);
+		return new OutputStreamWriter(fs, StandardCharsets.UTF_8);
+	}
+
+	// =========== String Process ===========
+
+	/**
+	 * Escape String
+	 * 
+	 * Escape all characters which are invalid in string quote.
+	 * 
+	 * @param strl The string need to be escaped.
+	 * @return The escaped string.
+	 * @see removeEol
+	 */
+	public static String escapeString(String strl) {
+		return strl.replace("\\", "\\\\").replace("\t", "\\t").replace("\b", "\\b").replace("\n", "\\n")
+				.replace("\r", "\\r").replace("\f", "\\f").replace("\"", "\\\"");
+	}
+
+	/**
+	 * Remove all EOL (End of Line) characters.
+	 * 
+	 * @param strl The string need to be processed.
+	 * @return The string eliminated all EOL.
+	 * @see escapeString
+	 */
+	public static String removeEol(String strl) {
+		return strl.replace("\n", "").replace("\r", "");
+	}
+
+	/**
+	 * Remove redundent star '*' (at least 5 continuous star chars)
+	 * 
+	 * @param cmt The string provided.
+	 * @return The string processed.
+	 */
+	public static String removeStars(String cmt) {
+		// only remove at least 5 continuous star chars.
+		return cmt.replaceAll("\\*{5,}", "");
+	}
+
+	/**
+	 * Get indent char by style
+	 * 
+	 * @param use_tab Whether indent use Tab, not Space.
+	 * @return The indent chars
+	 */
+	public static String getIndentString(boolean use_tab) {
+		if (use_tab)
+			return "\t";
+		else
+			return "    ";
+	}
+
+	/**
+	 * Re-indent a block of string
+	 * 
+	 * This function will first split block string by line. Then remove all indent
+	 * (strip Tab and Space). At last, re-indent and join each line
+	 * 
+	 * @param block_str    The string provided.
+	 * @param use_tab      Use Tab, not Space as indent chars.
+	 * @param indent_level The level of indent, started by 0.
+	 * @return The re-indent string
+	 */
+	public static String reindentBlockString(String block_str, boolean use_tab, int indent_level) {
+		// pre-create indent string
+		String indentChars = getIndentString(use_tab);
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < indent_level; ++i) {
+			sb.append(indentChars);
+		}
+		String indents = sb.toString();
+
+		// split line
+		return block_str.lines().map((String line) -> {
+			// strip space and tab, then re-indent it.
+			return indents + line.trim();
+		}).collect(Collectors.joining(System.lineSeparator())); // then join with new line breaker and return.
+	}
+
+}

Assets/CodeGen/EnumsMigration/CppWriter.java

@@ -0,0 +1,273 @@
+import java.io.OutputStreamWriter;
+import java.util.stream.Collectors;
+
+/**
+ * Write enum declarations and accessible value into C++ format.
+ */
+public class CppWriter {
+
+	// =========== C++ Enum Declaration Writer ===========
+
+	/**
+	 * Get corredponding C++ underlying type of given enum.
+	 * <p>
+	 * This is C++ specific function.
+	 * 
+	 * @param canUnsigned The parameter stored in Enum_t that indicate whether this
+	 *                    enum can use unsigned int as its underlying type.
+	 * @return The string form of its underlying type.
+	 */
+	private static String getEnumUnderlyingType(boolean canUnsigned) {
+		return canUnsigned ? "CKDWORD" : "CKINT";
+	}
+
+	/**
+	 * Internal real enum declarations writer.
+	 * 
+	 * @param writer {@linkplain java.io.OutputStreamWriter} instance for writing.
+	 * @param prog   {@linkplain EnumsHelper.EnumCollection_t} instance for writing.
+	 * @throws Exception
+	 */
+	private static void internalWriteEnums(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog)
+			throws Exception {
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum comment
+			indent.briefComment(enum_t.mEnumComment);
+
+			// write enum start
+			indent.printf("enum class %s : %s {", enum_t.mEnumName, getEnumUnderlyingType(enum_t.mCanUnsigned));
+			indent.inc();
+
+			// write enum entries
+			for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
+				// write entry self
+				if (enumEntry_t.mEntryValue == null) {
+					indent.printf("%s,", enumEntry_t.mEntryName);
+				} else {
+					indent.printf("%s = %s,", enumEntry_t.mEntryName, enumEntry_t.mEntryValue);
+				}
+
+				// write entry comment after member
+				indent.afterMemberComment(enumEntry_t.mEntryComment);
+			}
+
+			// write enum tail
+			indent.dec();
+			indent.puts("};");
+		}
+	}
+
+	/**
+	 * Write an enum collection into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum collection writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param prog     {@linkplain EnumsHelper.EnumCollection_t} instance for
+	 *                 writing.
+	 * @throws Exception
+	 */
+	public static void writeEnums(String filename, EnumsHelper.EnumCollection_t prog) throws Exception {
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteEnums(fs, prog);
+		fs.close();
+	}
+
+	/**
+	 * Write a single enum into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum collection writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param _enum    {@linkplain EnumsHelper.Enum_t} instance for writing.
+	 * @throws Exception
+	 */
+	public static void writeEnum(String filename, EnumsHelper.Enum_t _enum) throws Exception {
+		// create an collection from single enum declaration
+		// for suit the argument requirement of real writer.
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteEnums(fs, col);
+		fs.close();
+	}
+
+	// =========== C++ Enum Accessible Value Writer ===========
+
+	/**
+	 * Internal real enum collection accessible value writer.
+	 * 
+	 * @param writer {@linkplain java.io.OutputStreamWriter} instance for writing.
+	 * @param prog   {@linkplain EnumsHelper.EnumCollection_t} instance for writing.
+	 * @param parts  The part of these enum declarations. It will indicate the
+	 *               namespace where find given enum collection.
+	 * @throws Exception
+	 */
+	private static void internalWriteAccVals(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog,
+			CommonHelper.CKParts parts) throws Exception {
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
+		
+		// write type defination (just to let user know what the type is)
+		indent.puts("// struct GeneralReflection { const char8_t* mName; };");
+		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("");
+		indent.puts("");
+		indent.puts("");
+
+		// write declarations
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			indent.printf("extern const GeneralReflectionArray<LibCmo::%s::%s> %s;",
+					CommonHelper.getCKPartsNamespace(parts), enum_t.mEnumName, enum_t.mEnumName);
+		}
+
+		indent.puts("");
+		indent.puts("");
+		indent.puts("");
+
+		// write implements
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum desc header
+			indent.printf("const GeneralReflectionArray<LibCmo::%s::%s> %s {", CommonHelper.getCKPartsNamespace(parts),
+					enum_t.mEnumName, enum_t.mEnumName);
+			indent.inc();
+
+			// write enum desc entries
+			for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
+				indent.printf("{ LibCmo::%s::%s::%s, { u8\"%s\" } },", CommonHelper.getCKPartsNamespace(parts),
+						enum_t.mEnumName, enumEntry_t.mEntryName, enumEntry_t.mEntryName);
+			}
+
+			// write enum tail
+			indent.dec();
+			indent.puts("};");
+		}
+	}
+
+	/**
+	 * Write an enum collection accessible value into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum collection accessible value
+	 * writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param prog     {@linkplain EnumsHelper.EnumCollection_t} instance for
+	 *                 writing.
+	 * @param parts    The part of these enum declarations.
+	 * @throws Exception
+	 */
+	public static void writeAccVals(String filename, EnumsHelper.EnumCollection_t prog, CommonHelper.CKParts parts)
+			throws Exception {
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteAccVals(fs, prog, parts);
+		fs.close();
+	}
+
+	/**
+	 * Write a single enum accessible value into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum collection accessible value
+	 * writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param _enum    {@linkplain EnumsHelper.Enum_t} instance for writing.
+	 * @param parts    The part of these enum declarations.
+	 * @throws Exception
+	 */
+	public static void writeAccVal(String filename, EnumsHelper.Enum_t _enum, CommonHelper.CKParts parts)
+			throws Exception {
+		// create a enum collection to fulfill the requirement of internal writer.
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteAccVals(fs, col, parts);
+		fs.close();
+	}
+
+	// =========== Specialized C++ Enum Accessible Value Writer ===========
+	// Only accessible value part of CERROR and CK_CLASSID need to be specialized.
+	// The enum self do not need special treat. Just write them normally.
+
+	/**
+	 * Specialized CKERROR accessible value writer.
+	 * <p>
+	 * The declaration of CKERROR do not need special treat. It is okey to use
+	 * common writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param errors   The {@linkplain EnumsHelper.Enum_t} instance storing CKERROR.
+	 * @throws Exception
+	 */
+	public static void writeCkErrorAccVal(String filename, EnumsHelper.Enum_t errors) throws Exception {
+		OutputStreamWriter writer = CommonHelper.openOutputFile(filename);
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
+
+		// write type defination (just to let user know what the type is)
+		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("");
+		indent.puts("");
+		indent.puts("");
+
+		// write implementation
+		indent.puts("const CkErrorReflectionArray CKERROR {");
+		indent.inc();
+		for (EnumsHelper.EnumEntry_t entry : errors.mEntries) {
+			String comment = CommonHelper.escapeString(entry.mEntryComment);
+			if (comment == null)
+				comment = "";
+
+			indent.printf("{ LibCmo::CK2::CKERROR::%s, { u8\"%s\", u8\"%s\" } },", entry.mEntryName, entry.mEntryName,
+					comment);
+		}
+		indent.dec();
+		indent.puts("};");
+
+		writer.close();
+	}
+
+	/**
+	 * Specialized CK_CLASSID accessible value writer.
+	 * <p>
+	 * The declaration of CK_CLASSID do not need special treat. It is okey to use
+	 * common writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param classids The {@linkplain EnumsHelper.Enum_t} instance storing
+	 *                 CK_CLASSID.
+	 * @throws Exception
+	 */
+	public static void writeCkClassidAccVal(String filename, EnumsHelper.Enum_t classids) throws Exception {
+		OutputStreamWriter writer = CommonHelper.openOutputFile(filename);
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Cpp);
+
+		// write type defination (just to let user know what the type is)
+		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("");
+		indent.puts("");
+		indent.puts("");
+
+		indent.puts("const CkClassidReflectionArray CK_CLASSID {");
+		indent.inc();
+		for (EnumsHelper.EnumEntry_t entry : classids.mEntries) {
+			EnumsHelper.EnumEntryWithHierarchy_t specialized = (EnumsHelper.EnumEntryWithHierarchy_t) entry;
+
+			String hierarchy = specialized.mHierarchy.stream().map(value -> value.mEntryName)
+					.collect(Collectors.joining("\", u8\""));
+			indent.printf("{ LibCmo::CK2::CK_CLASSID::%s, { { u8\"%s\" } } },", entry.mEntryName, hierarchy);
+		}
+		indent.dec();
+		indent.puts("};");
+
+		writer.close();
+	}
+}

Assets/CodeGen/EnumsMigration/DefinesWalker.java

@@ -0,0 +1,73 @@
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+/**
+ * The generic walker for collecting defines as a enum.
+ */
+public class DefinesWalker extends CKDefinesParserBaseListener {
+	public DefinesWalker(BufferedTokenStream tokenStream) {
+		mCommentsFinder = new CommentsFinder(tokenStream);
+		mResult = null;
+
+		mCurrentEnum = null;
+		mCurrentEntry = null;
+	}
+	
+	public EnumsHelper.Enum_t getEnum() {
+		return mResult;
+	}
+	
+	private CommentsFinder mCommentsFinder;
+	private EnumsHelper.Enum_t mResult;
+
+	private EnumsHelper.Enum_t mCurrentEnum;
+	private EnumsHelper.EnumEntry_t mCurrentEntry;
+	
+	@Override
+	public void enterProg(CKDefinesParser.ProgContext ctx) {
+		mCurrentEnum = new EnumsHelper.Enum_t();
+	}
+
+	@Override
+	public void exitProg(CKDefinesParser.ProgContext ctx) {
+		mResult = mCurrentEnum;
+		mCurrentEnum = null;
+	}
+
+	@Override
+	public void enterDefinePair(CKDefinesParser.DefinePairContext ctx) {
+		mCurrentEntry = new EnumsHelper.EnumEntry_t();
+	}
+
+	@Override
+	public void exitDefinePair(CKDefinesParser.DefinePairContext ctx) {
+		// set values
+		mCurrentEntry.mEntryName = ctx.CKGENERAL_ID(0).getText();
+		mCurrentEntry.mEntryComment = mCommentsFinder.getComment(ctx.getStart(), ctx.getStop());
+		
+		if (ctx.CKGENERAL_NUM() == null) {
+			// define with id
+			mCurrentEntry.mEntryValue = ctx.CKGENERAL_ID(1).getText();
+			
+		} else {
+			// define with number
+			String num = ctx.CKGENERAL_NUM().getText();
+			mCurrentEntry.mEntryValue = num;
+
+			// check whether this enum can be unsigned
+			if (CommonHelper.isNegativeNumber(num)) {
+				mCurrentEnum.mCanUnsigned = false;
+			}
+			// if the number is in hex form, this enum MIGHT have flags feature
+			if (CommonHelper.isHexNumber(num)) {
+				mCurrentEnum.mUseFlags = true;
+			}
+
+		}
+		// add entry
+		mCurrentEnum.mEntries.add(mCurrentEntry);
+		mCurrentEntry = null;
+	}
+	
+}

Assets/CodeGen/EnumsMigration/EnumsHelper.java

@@ -0,0 +1,62 @@
+import java.util.Vector;
+
+public class EnumsHelper {
+	/**
+	 * The struct to describe the entry of an enum.
+	 */
+	public static class EnumEntry_t {
+		public EnumEntry_t() {
+			mEntryName = null;
+			mEntryValue = null;
+			mEntryComment = null;
+		}
+
+		public String mEntryName; ///< The name of this entry. Can not be null.
+		public String mEntryValue; ///< The value of this entry. null if this entry do not have explicit value.
+		public String mEntryComment; ///< The comment of this entry. null if no comment.
+	}
+	
+	/**
+	 * The specialized EnumEntry type which can store extra hierarchy info.
+	 * Used in CK_CLASSID parsing.
+	 */
+	public static class EnumEntryWithHierarchy_t extends EnumEntry_t {
+		public EnumEntryWithHierarchy_t() {
+			super();
+			mHierarchy = new Vector<EnumEntryWithHierarchy_t>();
+		}
+		
+		public Vector<EnumEntryWithHierarchy_t> mHierarchy; ///< The list to store this CK_CLASSID inheritance relationship.
+	}
+	
+	/**
+	 * The struct to describe an enum.
+	 */
+	public static class Enum_t {
+		public Enum_t() {
+			mEnumName = null;
+			mEnumComment = null;
+			mCanUnsigned = true;
+			mUseFlags = false;
+			mEntries = new Vector<EnumEntry_t>();
+		}
+
+		public String mEnumName; ///< The name of this enum. Can not be null.
+		public String mEnumComment; ///< The comment of this enum. null if no comment.
+		public boolean mCanUnsigned; ///< true if this enum can use unsigned integer as its underlaying type.
+		public boolean mUseFlags; ///< true if this enum will have flags feature (supporting OR, AND, operators).
+		public Vector<EnumEntry_t> mEntries; ///< The list to store entries of this enum.
+	}
+
+	/**
+	 * The struct to describe a collection of enums.
+	 */
+	public static class EnumCollection_t {
+		public EnumCollection_t() {
+			mEnums = new Vector<Enum_t>();
+		}
+
+		public Vector<Enum_t> mEnums; ///< The list to store enums.
+	}
+
+}

Assets/CodeGen/EnumsMigration/EnumsWalker.java

@@ -0,0 +1,131 @@
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+/**
+ * The generic walker for collecting multiple enums.
+ */
+public class EnumsWalker extends CKEnumsParserBaseListener {
+	public EnumsWalker(BufferedTokenStream tokenStream) {
+		mTokenStream = tokenStream;
+		mCommentsFinder = new CommentsFinder(tokenStream);
+		mResult = null;
+
+		mCurrentProg = null;
+		mCurrentEnum = null;
+		mCurrentEntry = null;
+	}
+
+	public EnumsHelper.EnumCollection_t getEnums() {
+		return mResult;
+	}
+
+	private String getEnumComment(Token enumHead) {
+		return CommonHelper
+				.cutComments(CommonHelper.getPreChannelTokens(mTokenStream, enumHead, CKGeneralLexer.COMMENTS));
+	}
+
+	private BufferedTokenStream mTokenStream;
+	private CommentsFinder mCommentsFinder;
+	private EnumsHelper.EnumCollection_t mResult;
+
+	private EnumsHelper.EnumCollection_t mCurrentProg;
+	private EnumsHelper.Enum_t mCurrentEnum;
+	private EnumsHelper.EnumEntry_t mCurrentEntry;
+
+	@Override
+	public void enterProg(CKEnumsParser.ProgContext ctx) {
+		mCurrentProg = new EnumsHelper.EnumCollection_t();
+	}
+
+	@Override
+	public void exitProg(CKEnumsParser.ProgContext ctx) {
+		mResult = mCurrentProg;
+		mCurrentProg = null;
+	}
+
+	@Override
+	public void enterEnumBody(CKEnumsParser.EnumBodyContext ctx) {
+		mCurrentEnum = new EnumsHelper.Enum_t();
+	}
+
+	@Override
+	public void exitEnumBody(CKEnumsParser.EnumBodyContext ctx) {
+		// get enum comment
+		mCurrentEnum.mEnumComment = getEnumComment(ctx.getStart());
+		// get the last name (for typedef case)
+		List<TerminalNode> allNames = ctx.CKGENERAL_ID();
+		mCurrentEnum.mEnumName = allNames.get(allNames.size() - 1).getText();
+
+		mCurrentProg.mEnums.add(mCurrentEnum);
+		mCurrentEnum = null;
+	}
+
+	@Override
+	public void enterEntryPair(CKEnumsParser.EntryPairContext ctx) {
+		mCurrentEntry = new EnumsHelper.EnumEntry_t();
+	}
+
+	@Override
+	public void exitEntryPair(CKEnumsParser.EntryPairContext ctx) {
+		// get entry comment
+		mCurrentEntry.mEntryComment = mCommentsFinder.getComment(ctx.getStart(), ctx.getStop());
+		// get entry name
+		mCurrentEntry.mEntryName = ctx.CKGENERAL_ID().getText();
+
+		mCurrentEnum.mEntries.add(mCurrentEntry);
+		mCurrentEntry = null;
+	}
+
+	@Override
+	public void exitEntryDirectValue(CKEnumsParser.EntryDirectValueContext ctx) {
+		// get all numbers
+		List<TerminalNode> nums = ctx.CKGENERAL_NUM();
+
+		switch (nums.size()) {
+		case 1: {
+			// set value
+			TerminalNode node = nums.get(0);
+			mCurrentEntry.mEntryValue = node.getText();
+
+			// check whether this enum can be unsigned
+			if (CommonHelper.isNegativeNumber(node.getText())) {
+				mCurrentEnum.mCanUnsigned = false;
+			}
+			// if the number is in hex form, this enum MIGHT have flags feature
+			if (CommonHelper.isHexNumber(node.getText())) {
+				mCurrentEnum.mUseFlags = true;
+			}
+
+			break;
+		}
+		case 2: {
+			// set value
+			TerminalNode num = nums.get(0), offset = nums.get(1);
+			mCurrentEntry.mEntryValue = String.format("%s << %s", num.getText(), offset.getText());
+
+			// << operator appears. this enum must have flags feature
+			mCurrentEnum.mUseFlags = true;
+
+			break;
+		}
+		default:
+			throw new IllegalArgumentException("Unexpected value: " + nums.size());
+		}
+
+	}
+
+	@Override
+	public void exitEntryRelativeValue(CKEnumsParser.EntryRelativeValueContext ctx) {
+		// get all identifiers and join them
+		mCurrentEntry.mEntryValue = ctx.CKGENERAL_ID().stream().map(value -> value.getText())
+				.collect(Collectors.joining(" | "));
+
+		// | operator appears. this enum must have flags feature
+		mCurrentEnum.mUseFlags = true;
+
+	}
+
+}

Assets/CodeGen/EnumsMigration/IndentHelper.java

@@ -0,0 +1,116 @@
+import java.io.OutputStreamWriter;
+
+public class IndentHelper {
+	public IndentHelper(OutputStreamWriter writer, CommonHelper.LangType lang_type) {
+		mIndent = 0;
+		mLangType = lang_type;
+		mWriter = writer;
+		
+		// set indent chars
+		switch (mLangType) {
+		case Cpp:
+		case CSharp:
+			mIndentChars = CommonHelper.getIndentString(true);
+			break;
+		case Python:
+			mIndentChars = CommonHelper.getIndentString(false);
+			break;
+		default:
+			mIndentChars = "";
+			break;
+		}
+	}
+
+	private int mIndent;
+	private CommonHelper.LangType mLangType;
+	private String mIndentChars;
+	private OutputStreamWriter mWriter;
+
+	private void rawIndent() throws Exception {
+		for (int i = 0; i < mIndent; ++i) {
+			mWriter.write(mIndentChars);
+		}
+	}
+	
+	public void inc() {
+		++mIndent;
+	}
+
+	public void dec() {
+		--mIndent;
+	}
+
+	public void indent() throws Exception {
+		mWriter.write(System.lineSeparator());
+		rawIndent();
+	}
+
+	public void puts(String data) throws Exception {
+		indent();
+		mWriter.write(data);
+	}
+
+	public void printf(String fmt, Object... args) throws Exception {
+		indent();
+		mWriter.write(String.format(fmt, args));
+	}
+
+	/**
+	 * Write standard Doxygen document comment.
+	 * <p>
+	 * Usually be called before writing content.
+	 * 
+	 * @param comment
+	 * @throws Exception
+	 */
+	public void briefComment(String comment) throws Exception {
+		if (comment == null)
+			return;
+		
+		switch (mLangType) {
+		case Cpp:
+		case CSharp:
+			puts("/**");
+			
+			mWriter.write(System.lineSeparator());
+			mWriter.write(CommonHelper.reindentBlockString(comment, true, mIndent));
+
+			puts(" */");
+			break;
+		case Python:
+			puts("\"\"\"!");
+
+			mWriter.write(System.lineSeparator());
+			mWriter.write(CommonHelper.reindentBlockString(comment, false, mIndent));
+
+			puts("\"\"\"");
+			break;
+		}
+	}
+
+	/**
+	 * Write suffix style Doxygen document comment.
+	 * <p>
+	 * Usually be called after writing content.
+	 * 
+	 * @param comment
+	 * @throws Exception
+	 */
+	public void afterMemberComment(String comment) throws Exception {
+		if (comment == null)
+			return;
+
+		mWriter.write(mIndentChars);
+		switch (mLangType) {
+		case Cpp:
+		case CSharp:
+			mWriter.write(String.format("/**< %s */", CommonHelper.removeEol(comment)));
+			break;
+		case Python:
+			mWriter.write(String.format("##< %s", CommonHelper.removeEol(comment)));
+			break;
+		}
+		
+	}
+
+}

Assets/CodeGen/EnumsMigration/MainRunner.java

@@ -0,0 +1,184 @@
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+public class MainRunner {
+
+	/**
+	 * Extract an enums collection from given file.
+	 * <p>
+	 * This function is the most commonly used function for extracting enums.
+	 * <p>
+	 * This function is used for a file which only contain enum declarations. This
+	 * is not suit for extracting CKERROR and CK_CLASSID. For these declarations,
+	 * please use their specialized extractor as described following.
+	 * 
+	 * @param infile The file for reading.
+	 * @return An {@linkplain EnumsHelper.EnumCollection_t} instance.
+	 * @throws Exception
+	 */
+	private static EnumsHelper.EnumCollection_t getEnumsCollection(String infile) throws Exception {
+		CommonHelper.InputFilePair pair = CommonHelper.openInputFile(infile);
+		CKGeneralLexer lexer = new CKGeneralLexer(pair.mAntlrStream);
+		CommonTokenStream tokens = new CommonTokenStream(lexer);
+		CKEnumsParser parser = new CKEnumsParser(tokens);
+
+		ParseTree tree = parser.prog();
+		ParseTreeWalker walker = new ParseTreeWalker();
+		EnumsWalker worker = new EnumsWalker(tokens);
+		walker.walk(worker, tree);
+
+		pair.mUnderlyingStream.close();
+		return worker.getEnums();
+	}
+
+	/**
+	 * Extract a series of "#define" syntax as an enum.
+	 * <p>
+	 * This function will assume that given file only contain C++ "#define" syntax.
+	 * After reading it, it will re-organize it as an enum and return. This only is
+	 * used by CKERROR now. But it suit for more scenarios if there are something
+	 * like CKERROR in future.
+	 *
+	 * @param infile           The file for reading.
+	 * @param assignedEnumName The desired name of organized enum instance.
+	 *                         Contemporary this field should always be "CKERROR"
+	 *                         because no one else is using it.
+	 * @return An {@linkplain EnumsHelper.Enum_t} instance.
+	 * @throws Exception
+	 */
+	private static EnumsHelper.Enum_t organiseDefines(String infile, String assignedEnumName) throws Exception {
+		CommonHelper.InputFilePair pair = CommonHelper.openInputFile(infile);
+		CKGeneralLexer lexer = new CKGeneralLexer(pair.mAntlrStream);
+		CommonTokenStream tokens = new CommonTokenStream(lexer);
+		CKDefinesParser parser = new CKDefinesParser(tokens);
+
+		ParseTree tree = parser.prog();
+		ParseTreeWalker walker = new ParseTreeWalker();
+		DefinesWalker worker = new DefinesWalker(tokens);
+		walker.walk(worker, tree);
+
+		pair.mUnderlyingStream.close();
+
+		EnumsHelper.Enum_t result = worker.getEnum();
+		result.mEnumName = assignedEnumName;
+		return result;
+	}
+
+	/**
+	 * Extract a series of macro define as an enum, considering its indent to build
+	 * hierarchy.
+	 * <p>
+	 * This is specialized enum extractor of CK_CLASSID. The given file should use a
+	 * series "#define" syntax to describe enum, and use Tab as the indent before
+	 * each "#define" syntax to indicate its hierarchy.
+	 * 
+	 * @param infile The file for reading.
+	 * @return An {@linkplain EnumsHelper.Enum_t} instance. Actually it is an
+	 *         instance to {@linkplain EnumsHelper.Enum_t} whose entries is
+	 *         {@linkplain EnumsHelper.EnumEntryWithHierarchy_t}, the child class of
+	 *         {@linkplain EnumsHelper.EnumEntry_t} (the entry type of common
+	 *         {@linkplain EnumsHelper.Enum_t}) with extra hierarchy infos.
+	 * @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);
+		CKDefinesParser parser = new CKDefinesParser(tokens);
+
+		ParseTree tree = parser.prog();
+		ParseTreeWalker walker = new ParseTreeWalker();
+		ClassidWalker worker = new ClassidWalker(tokens);
+		walker.walk(worker, tree);
+
+		pair.mUnderlyingStream.close();
+
+		EnumsHelper.Enum_t result = worker.getEnum();
+		result.mEnumName = "CK_CLASSID";
+		return result;
+	}
+
+	public static void main(String[] args) throws Exception {
+
+		// =========== CKERROR ===========
+		EnumsHelper.Enum_t ckerror = organiseDefines("src/CKERROR.txt", "CKERROR");
+		CppWriter.writeEnum("dest/CKERROR.hpp", ckerror);
+		PythonWriter.writeEnum("dest/CKERROR.py", ckerror);	
+		CSharpWriter.writeEnum("dest/CKERROR.cs", ckerror);
+		CppWriter.writeCkErrorAccVal("dest/CKERROR.AccVal.hpp", ckerror);
+		PythonWriter.writeAccVal("dest/CKERROR.AccVal.py", ckerror);
+		CSharpWriter.writeAccVal("dest/CKERROR.AccVal.cs", ckerror);
+
+		// =========== CK_CLASSID ===========
+		EnumsHelper.Enum_t classid = organiseClassid("src/CK_CLASSID.txt");
+		CppWriter.writeEnum("dest/CK_CLASSID.hpp", classid);
+		PythonWriter.writeEnum("dest/CK_CLASSID.py", classid);
+		CSharpWriter.writeEnum("dest/CK_CLASSID.cs", classid);
+		CppWriter.writeCkClassidAccVal("dest/CK_CLASSID.AccVal.hpp", classid);
+		PythonWriter.writeAccVal("dest/CK_CLASSID.AccVal.py", classid);
+
+		// =========== Define2 ===========
+		// Define2 do not need annotation output.
+		// Because they are CKStateChunk used value which are not exposed to outside.
+		EnumsHelper.EnumCollection_t def2 = getEnumsCollection("src/Defines2.txt");
+		CppWriter.writeEnums("dest/Defines2.hpp", def2);
+		PythonWriter.writeEnums("dest/Defines2.py", def2);
+		CSharpWriter.writeEnums("dest/Defines2.cs", def2);
+
+		// =========== Combined enums ===========
+		EnumsHelper.EnumCollection_t ck2Enums = getEnumsCollection("src/CKEnums.txt"),
+				vxEnums = getEnumsCollection("src/VxEnums.txt");
+		
+		CppWriter.writeEnums("dest/CKEnums.hpp", ck2Enums);
+		PythonWriter.writeEnums("dest/CKEnums.py", ck2Enums);
+		CSharpWriter.writeEnums("dest/CKEnums.cs", ck2Enums);
+		CppWriter.writeAccVals("dest/CKEnums.AccVal.hpp", ck2Enums, CommonHelper.CKParts.CK2);
+		PythonWriter.writeAccVals("dest/CKEnums.AccVal.py", ck2Enums);
+		CSharpWriter.writeAccVals("dest/CKEnums.AccVal.cs", ck2Enums);
+		
+		CppWriter.writeEnums("dest/VxEnums.hpp", vxEnums);
+		PythonWriter.writeEnums("dest/VxEnums.py", vxEnums);
+		CSharpWriter.writeEnums("dest/VxEnums.cs", vxEnums);
+		CppWriter.writeAccVals("dest/VxEnums.AccVal.hpp", vxEnums, CommonHelper.CKParts.VxMath);
+		PythonWriter.writeAccVals("dest/VxEnums.AccVal.py", vxEnums);
+		CSharpWriter.writeAccVals("dest/VxEnums.AccVal.cs", vxEnums);
+
+		// =========== Single enums ===========
+		EnumsHelper.Enum_t single;
+
+		single = organiseDefines("src/CK_STATECHUNK_CHUNKVERSION.txt", "CK_STATECHUNK_CHUNKVERSION");
+		CppWriter.writeEnum("dest/CK_STATECHUNK_CHUNKVERSION.hpp", single);
+		PythonWriter.writeEnum("dest/CK_STATECHUNK_CHUNKVERSION.py", single);
+		CSharpWriter.writeEnum("dest/CK_STATECHUNK_CHUNKVERSION.cs", single);
+		CppWriter.writeAccVal("dest/CK_STATECHUNK_CHUNKVERSION.AccVal.hpp", single, CommonHelper.CKParts.CK2);
+		PythonWriter.writeAccVal("dest/CK_STATECHUNK_CHUNKVERSION.AccVal.py", single);
+		CSharpWriter.writeAccVal("dest/CK_STATECHUNK_CHUNKVERSION.AccVal.cs", single);
+
+		single = organiseDefines("src/CK_STATECHUNK_DATAVERSION.txt", "CK_STATECHUNK_DATAVERSION");
+		CppWriter.writeEnum("dest/CK_STATECHUNK_DATAVERSION.hpp", single);
+		PythonWriter.writeEnum("dest/CK_STATECHUNK_DATAVERSION.py", single);
+		CSharpWriter.writeEnum("dest/CK_STATECHUNK_DATAVERSION.cs", single);
+		CppWriter.writeAccVal("dest/CK_STATECHUNK_DATAVERSION.AccVal.hpp", single, CommonHelper.CKParts.CK2);
+		PythonWriter.writeAccVal("dest/CK_STATECHUNK_DATAVERSION.AccVal.py", single);
+		CSharpWriter.writeAccVal("dest/CK_STATECHUNK_DATAVERSION.AccVal.cs", single);
+
+		single = organiseDefines("src/CK_BITMAPDATA_FLAGS.txt", "CK_BITMAPDATA_FLAGS");
+		CppWriter.writeEnum("dest/CK_BITMAPDATA_FLAGS.hpp", single);
+		PythonWriter.writeEnum("dest/CK_BITMAPDATA_FLAGS.py", single);
+		CSharpWriter.writeEnum("dest/CK_BITMAPDATA_FLAGS.cs", single);
+		CppWriter.writeAccVal("dest/CK_BITMAPDATA_FLAGS.AccVal.hpp", single, CommonHelper.CKParts.CK2);
+		PythonWriter.writeAccVal("dest/CK_BITMAPDATA_FLAGS.AccVal.py", single);
+		CSharpWriter.writeAccVal("dest/CK_BITMAPDATA_FLAGS.AccVal.cs", single);
+
+		single = organiseDefines("src/CK_CAMERA_PROJECTION.txt", "CK_CAMERA_PROJECTION");
+		CppWriter.writeEnum("dest/CK_CAMERA_PROJECTION.hpp", single);
+		PythonWriter.writeEnum("dest/CK_CAMERA_PROJECTION.py", single);
+		CSharpWriter.writeEnum("dest/CK_CAMERA_PROJECTION.cs", single);
+		CppWriter.writeAccVal("dest/CK_CAMERA_PROJECTION.AccVal.hpp", single, CommonHelper.CKParts.CK2);
+		PythonWriter.writeAccVal("dest/CK_CAMERA_PROJECTION.AccVal.py", single);
+		CSharpWriter.writeAccVal("dest/CK_CAMERA_PROJECTION.AccVal.cs", single);
+
+		// print message.
+		System.out.println("DONE!");
+	}
+}

Assets/CodeGen/EnumsMigration/PythonWriter.java

@@ -0,0 +1,185 @@
+import java.io.OutputStreamWriter;
+import java.util.Locale;
+
+/**
+ * Write enum declarations and accessible value into Python format.
+ */
+public class PythonWriter {
+
+	// =========== Python Enum Declaration Writer ===========
+
+	/**
+	 * Internal real enum declaration writer.
+	 * 
+	 * @param writer {@linkplain java.io.OutputStreamWriter} instance for writing.
+	 * @param prog   {@linkplain EnumsHelper.EnumCollection_t} instance for writing.
+	 * @throws Exception
+	 */
+	private static void internalWriteEnums(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog)
+			throws Exception {
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Python);
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum start
+			indent.printf("class %s(enum.IntEnum):", enum_t.mEnumName);
+			indent.inc();
+
+			// write enum comment
+			indent.briefComment(enum_t.mEnumComment);
+
+			// write enum entries
+			for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
+				// write entry self
+				if (enumEntry_t.mEntryValue == null) {
+					indent.printf("%s = auto()", enumEntry_t.mEntryName);
+				} else {
+					indent.printf("%s = %s", enumEntry_t.mEntryName,
+							CommonHelper.convertToPythonNumber(enumEntry_t.mEntryValue));
+				}
+
+				// write entry comment after member
+				indent.afterMemberComment(enumEntry_t.mEntryComment);
+			}
+
+			// enum tail
+			indent.dec();
+		}
+	}
+
+	/**
+	 * Write an enum declaration collection into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum declaration collection writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param prog     {@linkplain EnumsHelper.EnumCollection_t} instance for
+	 *                 writing.
+	 * @throws Exception
+	 */
+	public static void writeEnums(String filename, EnumsHelper.EnumCollection_t prog) throws Exception {
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteEnums(fs, prog);
+		fs.close();
+	}
+
+	/**
+	 * Write a single enum declaration into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum declaration collection writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param _enum    {@linkplain EnumsHelper.Enum_t} instance for writing.
+	 * @throws Exception
+	 */
+	public static void writeEnum(String filename, EnumsHelper.Enum_t _enum) throws Exception {
+		// create collection from single enum
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteEnums(fs, col);
+		fs.close();
+	}
+
+	// =========== Python Enum Accessible Value Writer ===========
+
+	/**
+	 * Try generate human readable name from enum entry name.
+	 * <p>
+	 * This function is only served for Python code generation.
+	 * <p>
+	 * As you noticed, almost entries of CK enums are fully capital and splitted by
+	 * underline. This is really not good for human reading, especially those who
+	 * are not programmer. So this function will try give these programmer-oriented
+	 * entry name a human readable name as its display name. However, this extract
+	 * method is not perfect. It simply do some split and replacement so the
+	 * generated content may still not good for reader.
+	 * 
+	 * @param entry_name The name of enum entry
+	 * @return A human readable entry name. No guaranteen that return value is must
+	 *         human readable.
+	 */
+	private static String extractHumanReadableEntryName(String entry_name) {
+		// remove first part (any content before underline '_')
+		entry_name = entry_name.replaceFirst("^[a-zA-Z0-9]+_", "");
+
+		// lower all chars except first char
+		if (entry_name.length() < 1)
+			return entry_name;
+		else
+			return entry_name.substring(0, 1) + entry_name.substring(1).toLowerCase(Locale.ROOT);
+	}
+
+	/**
+	 * Internal real enum accessible value writer.
+	 * 
+	 * @param writer {@linkplain java.io.OutputStreamWriter} instance for writing.
+	 * @param prog   {@linkplain EnumsHelper.EnumCollection_t} instance for writing.
+	 * @throws Exception
+	 */
+	private static void internalWriteAccVals(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog)
+			throws Exception {
+		IndentHelper indent = new IndentHelper(writer, CommonHelper.LangType.Python);
+
+		// write implements
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum desc header
+			indent.printf("g_Annotation_%s: dict[int, EnumAnnotation] = {", enum_t.mEnumName);
+			indent.inc();
+
+			// write enum desc entries
+			for (EnumsHelper.EnumEntry_t enumEntry_t : enum_t.mEntries) {
+				String comment = "";
+				if (enumEntry_t.mEntryComment != null) {
+					comment = CommonHelper.escapeString(enumEntry_t.mEntryComment);
+				}
+
+				indent.printf("%s.%s.value: EnumAnnotation(\"%s\", \"%s\"),", enum_t.mEnumName, enumEntry_t.mEntryName,
+						extractHumanReadableEntryName(enumEntry_t.mEntryName), comment);
+			}
+
+			// write enum tail
+			indent.dec();
+			indent.puts("}");
+		}
+	}
+
+	/**
+	 * Write an enum accessible value collection into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum accessible value collection
+	 * writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param prog     {@linkplain EnumsHelper.EnumCollection_t} instance for
+	 *                 writing.
+	 * @throws Exception
+	 */
+	public static void writeAccVals(String filename, EnumsHelper.EnumCollection_t prog) throws Exception {
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteAccVals(fs, prog);
+		fs.close();
+	}
+
+	/**
+	 * Write a single enum accessible value into given file.
+	 * <p>
+	 * Actually this is a wrapper of internal enum accessible value collection
+	 * writer.
+	 * 
+	 * @param filename The name of written file.
+	 * @param _enum    {@linkplain EnumsHelper.Enum_t} instance for writing.
+	 * @throws Exception
+	 */
+	public static void writeAccVal(String filename, EnumsHelper.Enum_t _enum) throws Exception {
+		// create a collection with single enum.
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		// open file and write
+		OutputStreamWriter fs = CommonHelper.openOutputFile(filename);
+		internalWriteAccVals(fs, col);
+		fs.close();
+	}
+
+}

Assets/CodeGen/EnumsMigration/README.md

@@ -0,0 +1,16 @@
+# Enums Migration
+
+A helper program to migrate existing Virtools enum declarations into other formats.
+
+Original Virtools SDK have various enum declarations. All of them are defined as C format and their formation are not uniform. This sub-project will use laxer and parser to recognize these diverse declarations, extract them as a series of uniform Java data struct and output them as C++ code (as C++ enum class syntax for LibCmo using), Python code (for PyBMap using), and C# code (for BMapSharp using).
+
+The steps processing existing enum declaration is called migration as this sub-project name told.
+
+```
+antlr4 CKGeneralLexer.g4
+antlr4 CKEnumsParser.g4
+antlr4 CKDefinesParser.g4
+
+javac *.java
+java MainRunner
+```

Assets/CodeGen/EnumsMigration/src/CKEnums.txt

@@ -0,0 +1,264 @@
+/*************************************************
+{filename:CK_FILE_WRITEMODE}
+Summary: Specify the way files are saved to disk (compression)
+
+Remarks :
+	+ File write mode controls the format of a Virtools file when saved. More specifically it 
+	controls whether compression is enabled and also if the Virtools Dev Interface specific data
+	should be stored in the file (if CKFILE_FORVIEWER flag is set , no interface data is saved)
+
+See also: CKContext::SetFileWriteMode,CKContext::GetFileWriteMode,CKContext::SetCompressionLevel,CKContext::SetGlobalImagesSaveOptions,CKContext::SetGlobalSoundsSaveOptions
+*************************************************/
+typedef enum CK_FILE_WRITEMODE 
+{
+	CKFILE_UNCOMPRESSED	       =0,	// Save data uncompressed
+	CKFILE_CHUNKCOMPRESSED_OLD =1,	// Obsolete
+	CKFILE_EXTERNALTEXTURES_OLD=2,	// Obsolete : use CKContext::SetGlobalImagesSaveOptions instead.
+	CKFILE_FORVIEWER           =4,	// Don't save Interface Data within the file, the level won't be editable anymore in the interface
+	CKFILE_WHOLECOMPRESSED     =8,	// Compress the whole file
+} CK_FILE_WRITEMODE;
+
+/*************************************************
+{filename:CK_LOAD_FLAGS}
+Summary: Load Options.
+
+Remarks:
++ This options apply when loading a Virtools file
+or a importing a 3D Model file. 
++ They defines whether object geometry,only animations 
+or only behaviors should be loaded.
++ One can specify (using the CK_LOAD_AS_DYNAMIC_OBJECT) if 
+created CKObjects should be created as dynamic (See also Dynamic Objects)
+See also : CKContext::Load,CKContext::CKSave
+*************************************************/
+typedef enum CK_LOAD_FLAGS {
+			CK_LOAD_ANIMATION					=1<<0,	// Load animations
+			CK_LOAD_GEOMETRY					=1<<1,	// Load geometry.
+			CK_LOAD_DEFAULT						=CK_LOAD_GEOMETRY|CK_LOAD_ANIMATION,	// Load animations & geometry
+			CK_LOAD_ASCHARACTER					=1<<2, // Load all the objects and create a character that contains them all .
+			CK_LOAD_DODIALOG					=1<<3, // Check object name unicity and warns the user with a dialog box when duplicate names are found. 
+			CK_LOAD_AS_DYNAMIC_OBJECT			=1<<4, // Objects loaded from this file may be deleted at run-time or are temporary
+			CK_LOAD_AUTOMATICMODE				=1<<5, // Check object name unicity and automatically rename or replace according to the options specified in CKContext::SetAutomaticLoadMode
+			CK_LOAD_CHECKDUPLICATES				=1<<6, // Check object name unicity (The list of duplicates is stored in the CKFile class after a OpenFile call
+			CK_LOAD_CHECKDEPENDENCIES			=1<<7, // Check if every plugins needed are availables
+			CK_LOAD_ONLYBEHAVIORS				=1<<8, // 
+} CK_LOAD_FLAGS;
+
+// Options that will be used to create this object...
+	enum CK_FO_OPTIONS {
+		CK_FO_DEFAULT = 0,		 // Default behavior : a new object will be created with the name stored in CKFileObject
+		CK_FO_RENAMEOBJECT,		 // Renaming : a new object will be created with the name stored in CKFileObject + a integer value XXX to ensure its uniqueness
+		CK_FO_REPLACEOBJECT,	 // Do not create a new object, instead use an existing one which CK_ID is given by CreatedObject   	
+								 // to load the chunk on 
+		CK_FO_DONTLOADOBJECT,	 // Object chunk will not be read either because it is a reference
+								// 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}
+Summary: Type identifier for a Virtools plugin.
+Remarks: 
+	+ Each plugin must be given a type.
+	+ This enumeration is used to identify a specific catagory 
+	of plugin when using the CKPluginManager.
+
+See also: CKPluginManager,Creating New Plugins
+*************************************************/
+typedef enum CK_PLUGIN_TYPE {
+	CKPLUGIN_BITMAP_READER		= 0,	// The plugin is bitmap (textures,sprites) loader
+	CKPLUGIN_SOUND_READER		= 1,	// Sound Reader Plugin
+	CKPLUGIN_MODEL_READER		= 2,	// 3D Model Reader 
+	CKPLUGIN_MANAGER_DLL		= 3,	// The plugin implements a Manager
+	CKPLUGIN_BEHAVIOR_DLL		= 4,	// The plugin implements one or more behaviors
+	CKPLUGIN_RENDERENGINE_DLL	= 5,	// Render Engine plugin
+	CKPLUGIN_MOVIE_READER		= 6,	// Movie (AVI,Mpeg) reader		
+	CKPLUGIN_EXTENSION_DLL		= 7,	// Generic extension (definition of new parameter types or operations for ex.)	
+} CK_PLUGIN_TYPE;
+
+/***************************************************
+CHUNK_OPTIONS in Virtools header.
+*************************************************/
+enum CK_STATECHUNK_CHUNKOPTIONS {
+	CHNK_OPTION_IDS			= 0x01,		// IDS are stored inside chunk
+	CHNK_OPTION_MAN			= 0x02,		// Managers ints are store inside chunk
+	CHNK_OPTION_CHN			= 0x04,		// Sub chunk are stored	inside chunk
+	CHNK_OPTION_FILE		= 0x08,		// Chunk was written with indices relative to a file....  
+	CHNK_OPTION_ALLOWDYN	= 0x10,		// Dynamic object can be written in the chunk 
+	CHNK_OPTION_LISTBIG		= 0x20,		// List are store in big Endian ? 
+	CHNK_DONTDELETE_PTR		= 0x40,		// Data buffer stored in m_Buffer is not owned by CKStateChunk , it must not be deleted...
+	CHNK_DONTDELETE_PARSER	= 0x80,		// m_Parser Ptr is not owned by CKStateChunk , it must not be deleted...
+};
+
+typedef enum CK_OBJECT_SHOWOPTION {
+	CKHIDE				=0,
+	CKSHOW				=1,
+	CKHIERARCHICALHIDE	=2
+} CK_OBJECT_SHOWOPTION;
+
+/***************************************************
+{filename:CK_OBJECT_FLAGS}
+Summary: CKObject Flags
+
+Remarks:
++ Flags specifying special settings for basic objects.
++ Some of this flags are shared with sub-classes such as CKParameterIn,CKParameterOut and CKBehaviorIO.
++ You rarely need to modify directly this flags through CKObject::SetFlags or CKObject::ModifyObjectFlags instead
+you should always use the specific acces function (given between ()) which may need to perform additionnal operations.
+See also: CKObject,CKObject::GetObjectFlags,CKObject::ModifyObjectFlags
+*************************************************/
+typedef enum CK_OBJECT_FLAGS {
+	CK_OBJECT_INTERFACEOBJ			=	 0x00000001,		// Reserved for Inteface Use
+	CK_OBJECT_PRIVATE				=	 0x00000002,		// The object must not be displayed in interface (Lists,Level view,etc...),nor should it be saved. (CKObject::IsPrivate()
+	CK_OBJECT_INTERFACEMARK			=	 0x00000004,		
+	CK_OBJECT_FREEID				=	 0x00000008,		// ID of this object can be released safely and is free to be reused by future CKobjects.
+	CK_OBJECT_TOBEDELETED			=	 0x00000010,		// This object is being deleted
+	CK_OBJECT_NOTTOBESAVED			=	 0x00000020,		// This object must not be saved 
+	CK_OBJECT_VISIBLE				=	 0x00000040,		// This object is visible (CKObject::Show)
+	CK_OBJECT_NAMESHARED			=	 0x00000080,		// This object has its name from another entity
+	CK_OBJECT_DYNAMIC				=	 0x00000108,		// This object may be created or deleted at run-time, it also contails CK_OBJECT_FREEID. (CKObject::IsDynamic,CKContext::CreateObject)
+	CK_OBJECT_HIERACHICALHIDE		=	 0x00000200,		// This object hides all its hierarchy (CKObject::Show)
+	CK_OBJECT_UPTODATE				=	 0x00000400,		// (Camera,etc..)
+	CK_OBJECT_TEMPMARKER			=	 0x00000800,		
+	CK_OBJECT_ONLYFORFILEREFERENCE	=	 0x00001000,		
+	CK_OBJECT_NOTTOBEDELETED		=	 0x00002000,		// This object must not be deleted in a clear all
+	CK_OBJECT_APPDATA				=	 0x00004000,		// This object has app data	
+	CK_OBJECT_SINGLEACTIVITY		=	 0x00008000,		// this object has an information of single activity
+	CK_OBJECT_LOADSKIPBEOBJECT		=	 0x00010000,		// When loading this object the CKBeObject part should be skipped
+	
+	CK_OBJECT_NOTTOBELISTEDANDSAVED	=	 0x00000023,		// Combination of Private and Not To Be Saved
+
+
+// The following flags are specific to parameters (they are stored here for object's size purposes )
+	CK_PARAMETEROUT_SETTINGS		=	0x00400000,			
+	CK_PARAMETEROUT_PARAMOP			=	0x00800000,			// This parameter is the output of a CKParameterOperation (Automatically set by Engine)
+	CK_PARAMETERIN_DISABLED			=	0x01000000,			// Parameter In or Out is disabled (CKBehavior::EnableInputParameter,CKBehavior::DisableInputParameter)	
+	CK_PARAMETERIN_THIS				=	0x02000000,			// Special parameter type : its value and type are always equal to its owner (CKParameter::SetAsMyselfParameter)
+	CK_PARAMETERIN_SHARED		    =	0x04000000,			
+	CK_PARAMETEROUT_DELETEAFTERUSE 	=	0x08000000,			// When adding parameters to CKMessage, they can be automatically deleted when message is released (CKMessage::AddParameter)
+	CK_OBJECT_PARAMMASK			  	=	0x0FC00000,			// Mask for options specific to parameters	
+
+// The Following flags are specific	for Behavior ios (CKBehaviorIO)
+	CK_BEHAVIORIO_IN				=	0x10000000,		// This BehaviorIO is a behavior input  (CKBehaviorIO::SetType}
+	CK_BEHAVIORIO_OUT				=	0x20000000,		// This BehaviorIO is a behavior output (CKBehaviorIO::SetType)	
+	CK_BEHAVIORIO_ACTIVE			=	0x40000000,		// This BehaviorIO is a currently active (CKBehaviorIO::Activate}
+	CK_OBJECT_IOTYPEMASK		  	=	0x30000000,		
+	CK_OBJECT_IOMASK			  	=	0xF0000000,		
+
+	// The Following flags are specific	for Behavior ios (CKBehaviorIO)
+	CKBEHAVIORLINK_RESERVED			=	0x10000000,		// This BehaviorIO is a behavior input  (CKBehaviorIO::SetType}
+	CKBEHAVIORLINK_ACTIVATEDLASTFRAME =	0x20000000,		// This link had been activated last frame
+	CK_OBJECT_BEHAVIORLINKMASK		=	0x30000000,		
+} CK_OBJECT_FLAGS;
+
+
+/*************************************************
+{filename:CK_3DENTITY_FLAGS}
+Summary: 3dEntity Flags
+Remarks:
+	+ Flags give user and engine more information about the 3dEntity.
+
+See also: CK3dEntity::SetFlags,CK3dEntity::GetFlags,
+*************************************************/
+typedef enum CK_3DENTITY_FLAGS {
+		CK_3DENTITY_DUMMY				=	0x00000001,		// Entity is a dummy used to represent a position
+		CK_3DENTITY_FRAME				=	0x00000002,		// Entity is a frame used to represent an orientation
+		CK_3DENTITY_RESERVED0			=	0x00000020,		// Obsolete Flag
+		CK_3DENTITY_TARGETLIGHT			=	0x00000100,		// Entity is a target of a light
+		CK_3DENTITY_TARGETCAMERA		=	0x00000200,		// Entity is a target of a camera
+		CK_3DENTITY_IGNOREANIMATION		=	0x00000400,		// Animation using this entity can't modify it
+		CK_3DENTITY_HIERARCHICALOBSTACLE=	0x00000800,		// Used by the Collision Manager
+		CK_3DENTITY_UPDATELASTFRAME     =   0x00001000,		// Store the last world matrix for this Entity after each render
+		CK_3DENTITY_CAMERAIGNOREASPECT  =   0x00002000,		// Ignore aspect ratio setting for cameras
+		CK_3DENTITY_DISABLESKINPROCESS	=   0x00004000,		// Force skin processing to be disabled
+		CK_3DENTITY_ENABLESKINOFFSET	=   0x00008000,		// If not set the skin stay attached to the bones the vertices are linked to, otherwise the skin can be freely rotated,translated or scaled according to its owner entity matrix.
+		CK_3DENTITY_PLACEVALID			=   0x00010000,		// Used internally when saving 
+		CK_3DENTITY_PARENTVALID			=	0x00020000,		// Used internally when saving 
+		CK_3DENTITY_IKJOINTVALID		=	0x00040000,		// Special flag for Bodyparts : IK Joint data is valid
+		CK_3DENTITY_PORTAL				=	0x00080000,		// The 3dEntity is a portal
+		CK_3DENTITY_ZORDERVALID			=	0x00100000,		// The 3dEntity has a non-zero ZOrder
+		CK_3DENTITY_CHARACTERDOPROCESS	=	0x80000000,		// Special flag for Characters : Automatic process of animation
+} CK_3DENTITY_FLAGS;
+
+
+/*************************************************
+{filename:CK_TEXTURE_SAVEOPTIONS}
+Summary: Specify the way textures or sprites will be saved
+
+Remarks : 
+	+ Textures can be stored inside Virtools files or kept as references to external files.
+	+ These options can be used for a specific texture (or sprite) or as a global setting.
+See also: CKBitmapData::SetSaveOptions,CKSprite::SetSaveOptions,CKContext::SetGlobalImagesSaveOptions
+*************************************************/
+typedef enum CK_TEXTURE_SAVEOPTIONS 
+{
+	CKTEXTURE_RAWDATA				=0,	// Save raw data inside file. The bitmap is saved in a raw 32 bit per pixel format. 
+	CKTEXTURE_EXTERNAL				=1,	// Store only the file name for the texture. The bitmap file must be present in the bitmap paths 
+										// when loading the composition.
+	CKTEXTURE_IMAGEFORMAT			=2,	// Save using format specified. The bitmap data will be converted to the 
+										// specified format by the correspondant bitmap plugin and saved inside file. 
+	CKTEXTURE_USEGLOBAL				=3,	// Use Global settings, that is the settings given with CKContext::SetGlobalImagesSaveOptions. (Not valid when using CKContext::SetImagesSaveOptions). 
+	CKTEXTURE_INCLUDEORIGINALFILE	=4,	// Insert original image file inside CMO file. The bitmap file that 
+										// was used originally for the texture or sprite will be append to 
+										// the composition file and extracted when the file is loaded.
+} CK_TEXTURE_SAVEOPTIONS;
+
+
+/*************************************************
+{filename:CK_SOUND_SAVEOPTIONS}
+Summary: Specify the way sounds will be saved
+
+Remarks : 
++ Sounds can kept as references to external files or the original sound file can
+be appended to the composition file.
++ These options can be used for a specific sound or as a global setting.
+See also: CKSound::SetSaveOptions,CKContext::SetGlobalSoundSaveOptions
+*************************************************/
+typedef enum CK_SOUND_SAVEOPTIONS 
+{
+	CKSOUND_EXTERNAL				=0,	// Store only the file name for the sound. The sound file must be present
+										// in one of the sound paths when the composition is loaded.
+	CKSOUND_INCLUDEORIGINALFILE		=1,	// Insert original sound file inside the CMO file. The sound file that 
+										// was used originally will be append to  the composition file and
+										// extracted when the file is loaded.
+	CKSOUND_USEGLOBAL				=2,	// Use Global settings. This flag is only valid for the CKSound::SetSaveOptions method.
+} CK_SOUND_SAVEOPTIONS;

Assets/CodeGen/EnumsMigration/src/CKError.txt

@@ -0,0 +1,205 @@
+// Operation successful
+
+#define CKERR_OK           0
+
+// One of the parameter passed to the function was invalid
+
+#define CKERR_INVALIDPARAMETER      -1
+
+// One of the parameter passed to the function was invalid
+
+#define CKERR_INVALIDPARAMETERTYPE     -2
+
+// The parameter size was invalid
+
+#define CKERR_INVALIDSIZE       -3
+
+// The operation type didn't exist
+
+#define CKERR_INVALIDOPERATION      -4
+
+// The function used to execute the operation is not yet implemented
+
+#define CKERR_OPERATIONNOTIMPLEMENTED    -5
+
+// There was not enough memory to perform the action
+
+#define CKERR_OUTOFMEMORY       -6
+
+// The function  is not yet implemented
+
+#define CKERR_NOTIMPLEMENTED      -7
+
+// There was an attempt to remove something not present
+
+#define CKERR_NOTFOUND        -11
+
+// There is no level currently created
+
+#define CKERR_NOLEVEL        -13
+
+// 
+
+#define CKERR_CANCREATERENDERCONTEXT    -14
+
+// The notification message was not used
+
+#define CKERR_NOTIFICATIONNOTHANDLED    -16
+
+// Attempt to add an item that was already present 
+
+#define CKERR_ALREADYPRESENT      -17
+
+// the render context is not valid
+
+#define CKERR_INVALIDRENDERCONTEXT     -18
+
+// the render context is not activated for rendering
+
+#define CKERR_RENDERCONTEXTINACTIVE     -19
+
+// there was no plugins to load this kind of file
+
+#define CKERR_NOLOADPLUGINS       -20
+
+// there was no plugins to save this kind of file
+
+#define CKERR_NOSAVEPLUGINS       -21
+
+// attempt to load an invalid file
+
+#define CKERR_INVALIDFILE       -22
+
+// attempt to load with an invalid plugin
+
+#define CKERR_INVALIDPLUGIN       -23
+
+// attempt use an object that wasnt initialized
+
+#define  CKERR_NOTINITIALIZED      -24
+
+// attempt use a message type that wasn't registred
+
+#define  CKERR_INVALIDMESSAGE      -25
+
+// attempt use an invalid prototype
+
+#define CKERR_INVALIDPROTOTYPE               -28
+
+// No dll file found in the parse directory
+
+#define CKERR_NODLLFOUND       -29
+
+// this dll has already been registred 
+
+#define CKERR_ALREADYREGISTREDDLL     -30
+
+// this dll does not contain information to create the prototype
+
+#define CKERR_INVALIDDLL       -31
+
+// Invalid Object (attempt to Get an object from an invalid ID)
+
+#define CKERR_INVALIDOBJECT       -34
+
+// Invalid window was provided as console window 
+
+#define CKERR_INVALIDCONDSOLEWINDOW     -35
+
+// Invalid kinematic chain ( end and start effector may not be part of the same hierarchy )
+
+#define CKERR_INVALIDKINEMATICCHAIN     -36 
+
+
+// Keyboard not attached or not working properly
+
+#define CKERR_NOKEYBOARD       -37 
+
+// Mouse not attached or not working properly
+
+#define CKERR_NOMOUSE        -38 
+
+// Joystick not attached or not working properly
+
+#define CKERR_NOJOYSTICK       -39 
+
+// Try to link imcompatible Parameters
+
+#define CKERR_INCOMPATIBLEPARAMETERS    -40
+
+// There is no render engine dll 
+
+#define CKERR_NORENDERENGINE      -44 
+
+// There is no current level (use CKSetCurrentLevel )
+
+#define CKERR_NOCURRENTLEVEL      -45 
+
+// Sound Management has been disabled
+
+#define CKERR_SOUNDDISABLED       -46 
+
+// DirectInput Management has been disabled
+
+#define CKERR_DINPUTDISABLED      -47 
+
+// Guid is already in use or invalid 
+
+#define CKERR_INVALIDGUID       -48 
+
+// There was no more free space on disk when trying to save a file
+
+#define CKERR_NOTENOUGHDISKPLACE     -49 
+
+// Impossible to write to file (write-protection ?)
+
+#define CKERR_CANTWRITETOFILE      -50 
+
+// The behavior cannnot be added to this entity 
+
+#define CKERR_BEHAVIORADDDENIEDBYCB     -51 
+
+// The behavior cannnot be added to this entity 
+
+#define CKERR_INCOMPATIBLECLASSID     -52 
+
+// A manager was registered more than once
+
+#define CKERR_MANAGERALREADYEXISTS     -53 
+
+// CKprocess or TimeManager process while CK is paused will fail
+
+#define CKERR_PAUSED        -54 
+
+// Some plugins were missing whileloading a file
+
+#define CKERR_PLUGINSMISSING      -55 
+
+// Virtools version too old to load this file
+
+#define CKERR_OBSOLETEVIRTOOLS      -56 
+
+// CRC Error while loading file
+
+#define CKERR_FILECRCERROR       -57
+
+// A Render context is already in Fullscreen Mode
+
+#define CKERR_ALREADYFULLSCREEN      -58
+
+// Operation was cancelled by user
+
+#define CKERR_CANCELLED        -59
+
+
+// there were no animation key at the given index
+
+#define CKERR_NOANIMATIONKEY      -121
+
+// attemp to acces an animation key with an invalid index
+
+#define CKERR_INVALIDINDEX       -122
+
+// the animation is invalid (no entity associated or zero length)
+
+#define CKERR_INVALIDANIMATION      -123

Assets/CodeGen/EnumsMigration/src/CK_BITMAPDATA_FLAGS.txt

@@ -0,0 +1,14 @@
+
+#define CKBITMAPDATA_INVALID		1		
+
+#define CKBITMAPDATA_TRANSPARENT	2		
+
+#define CKBITMAPDATA_FORCERESTORE	4		
+
+#define CKBITMAPDATA_CLAMPUPTODATE	8		
+
+#define CKBITMAPDATA_CUBEMAP		16		
+
+#define CKBITMAPDATA_FREEVIDEOMEMORY 32		
+
+#define CKBITMAPDATA_DYNAMIC		 64		

Assets/CodeGen/EnumsMigration/src/CK_CAMERA_PROJECTION.txt

@@ -0,0 +1,4 @@
+
+#define CK_PERSPECTIVEPROJECTION  1
+
+#define CK_ORTHOGRAPHICPROJECTION 2

Assets/CodeGen/EnumsMigration/src/CK_CLASSID.txt

@@ -0,0 +1,69 @@
+#define  CKCID_OBJECT					1		
+	#define  CKCID_PARAMETERIN				2	
+	#define  CKCID_PARAMETEROPERATION		4	
+	#define  CKCID_STATE					5	
+	#define  CKCID_BEHAVIORLINK				6	
+	#define  CKCID_BEHAVIOR					8	
+	#define  CKCID_BEHAVIORIO				9	
+	#define  CKCID_RENDERCONTEXT			12	
+	#define  CKCID_KINEMATICCHAIN			13	
+	#define  CKCID_SCENEOBJECT				11		
+		#define  CKCID_OBJECTANIMATION			15	
+		#define  CKCID_ANIMATION				16	
+			#define  CKCID_KEYEDANIMATION		18	
+		#define  CKCID_BEOBJECT					19	
+			#define	 CKCID_DATAARRAY			52	
+			#define  CKCID_SCENE				10	
+			#define  CKCID_LEVEL				21	
+			#define  CKCID_PLACE				22	
+			#define  CKCID_GROUP				23	
+			#define  CKCID_SOUND				24	
+				#define  CKCID_WAVESOUND		25	
+				#define  CKCID_MIDISOUND		26	
+			#define  CKCID_MATERIAL				30	
+			#define  CKCID_TEXTURE				31	
+			#define  CKCID_MESH					32	
+				#define CKCID_PATCHMESH			53	
+			#define  CKCID_RENDEROBJECT			47	
+				#define  CKCID_2DENTITY			27	
+					#define  CKCID_SPRITE		28	
+					#define  CKCID_SPRITETEXT	29	
+			#define  CKCID_3DENTITY				33	
+				#define CKCID_GRID				50	
+				#define  CKCID_CURVEPOINT		36	
+				#define  CKCID_SPRITE3D			37	
+				#define  CKCID_CURVE			43	
+				#define  CKCID_CAMERA			34	
+					#define  CKCID_TARGETCAMERA	35	
+				#define  CKCID_LIGHT			38	
+					#define  CKCID_TARGETLIGHT	39	
+				#define  CKCID_CHARACTER		40	
+				#define  CKCID_3DOBJECT			41	
+					#define  CKCID_BODYPART		42	
+	#define  CKCID_PARAMETER				46		
+		#define  CKCID_PARAMETERLOCAL		45	
+		#define  CKCID_PARAMETEROUT			3	
+	#define CKCID_INTERFACEOBJECTMANAGER	48	
+	#define CKCID_CRITICALSECTION			49	
+	#define CKCID_LAYER						51	
+	#define CKCID_PROGRESSIVEMESH			54		
+	#define CKCID_SYNCHRO					20	
+
+#define  CKCID_OBJECTARRAY				80	
+#define  CKCID_SCENEOBJECTDESC			81	
+#define  CKCID_ATTRIBUTEMANAGER			82	
+#define  CKCID_MESSAGEMANAGER			83	
+#define  CKCID_COLLISIONMANAGER			84	
+#define  CKCID_OBJECTMANAGER			85	
+#define  CKCID_FLOORMANAGER				86	
+#define  CKCID_RENDERMANAGER			87	
+#define  CKCID_BEHAVIORMANAGER			88	
+#define  CKCID_INPUTMANAGER				89	
+#define  CKCID_PARAMETERMANAGER			90	
+#define  CKCID_GRIDMANAGER				91	
+#define  CKCID_SOUNDMANAGER				92	
+#define  CKCID_TIMEMANAGER				93	
+#define  CKCID_CUIKBEHDATA				-1	
+
+#define CKCID_MAXCLASSID				55
+#define  CKCID_MAXMAXCLASSID			128

Assets/CodeGen/EnumsMigration/src/CK_STATECHUNK_CHUNKVERSION.txt

@@ -0,0 +1,6 @@
+
+	#define CHUNK_VERSIONBASE	0 
+	#define CHUNK_VERSION1		4	// equal to file version : WriteObjectID => table
+	#define CHUNK_VERSION2		5	// add Manager Data
+	#define CHUNK_VERSION3		6	// New ConvertToBuffer / ReadFromBuffer (file system changed to reflect this )
+	#define CHUNK_VERSION4		7	// New WriteObjectID when saving to a file 

Assets/CodeGen/EnumsMigration/src/CK_STATECHUNK_DATAVERSION.txt

@@ -0,0 +1,14 @@
+
+#define CHUNKDATA_OLDVERSION			0	// Before any version was saved 
+#define CHUNKDATA_BASEVERSION			1	// First version	
+#define CHUNK_WAVESOUND_VERSION2		2	// Changes in wavesound format	
+#define CHUNK_WAVESOUND_VERSION3		3	// Changes in wavesound format	
+#define CHUNK_MATERIAL_VERSION_ZTEST	4	// Change in material save format	
+#define CHUNK_MAJORCHANGE_VERSION		5	// Optimisations on many save functions		
+#define CHUNK_MACCHANGE_VERSION			6	// Misc new Statechunk functions for macintosh (Big-Endian <-> Little Endian conversion )	
+#define CHUNK_WAVESOUND_VERSION4		7	// Changes in wavesound format (Added sound length)	
+#define CHUNK_SCENECHANGE_VERSION		8	// Changes in sceneObjectDesc format (Remove lasttimevalue)	
+#define CHUNK_MESHCHANGE_VERSION		9	// Changes in Mesh save format (primitives)	
+#define CHUNK_DEV_2_1				   10	// Changes in wavesound reading of inside, outside angles 
+
+#define CHUNKDATA_CURRENTVERSION		CHUNK_DEV_2_1	

Assets/CodeGen/EnumsMigration/src/Defines2.txt

@@ -0,0 +1,722 @@
+
+//------------------------------------------------
+// Object								
+typedef enum CK_STATESAVEFLAGS_OBJECT {
+		CK_STATESAVE_NAME				= 0x00000001,	// Obsolete
+		CK_STATESAVE_ID					= 0x00000002,	// Obsolete
+		CK_STATESAVE_OBJECTHIDDEN		= 0x00000004,	// The object is hidden
+		CK_STATESAVE_OBJECTHIERAHIDDEN	= 0x00000018,	// The object is hidden hierarchically
+		CK_STATESAVE_OBJECTALL			= 0x0000000F
+} CK_STATESAVEFLAGS_OBJECT;
+
+
+//------------------------------------------------
+// Be Object							
+typedef enum CK_STATESAVEFLAGS_BEOBJECT 
+{
+		 CK_STATESAVE_ATTRIBUTES		= 0x00000010,	// Obsolete
+		 CK_STATESAVE_NEWATTRIBUTES		= 0x00000011,	// Save Attributes
+		 CK_STATESAVE_GROUPS			= 0x00000020,	// Obsolete
+		 CK_STATESAVE_DATAS				= 0x00000040,	// Save Flags and (Waiting for message) status
+		 CK_STATESAVE_SOUNDS			= 0x00000080,	// Obsolete
+		 CK_STATESAVE_BEHAVIORS			= 0x00000100,	// Obsolete
+		 CK_STATESAVE_PARAMETERS		= 0x00000200,	// Obsolete
+		 CK_STATESAVE_SINGLEACTIVITY	= 0x00000400,	// SINGLE ACTIVITY
+		 CK_STATESAVE_SCRIPTS			= 0x00000800,	// Obsolete
+		 CK_STATESAVE_BEOBJECTONLY		= 0x00000FF0,	// Save only BeObject specific datas
+		 CK_STATESAVE_BEOBJECTALL		= 0x00000FFF	// Save All datas
+} CK_STATESAVEFLAGS_BEOBJECT;
+
+
+//------------------------------------------------									
+// 3dEntity								
+typedef enum CK_STATESAVEFLAGS_3DENTITY 
+{
+		 CK_STATESAVE_3DENTITYSKINDATANORMALS	= 0x00001000,	// Save Skin normals
+		 CK_STATESAVE_ANIMATION			= 0x00002000,	// Obsolete
+		 CK_STATESAVE_MESHS				= 0x00004000,	// Save List of mesh
+		 CK_STATESAVE_PARENT			= 0x00008000,	// Save Parent
+		 CK_STATESAVE_3DENTITYFLAGS		= 0x00010000,	// Save Flags
+		 CK_STATESAVE_3DENTITYMATRIX	= 0x00020000,	// Save Position/orientation/Scale
+		 CK_STATESAVE_3DENTITYHIERARCHY	= 0x00040000,	// obsolete
+		 CK_STATESAVE_3DENTITYPLACE		= 0x00080000,	// Save Place in which the Entity is referenced
+		 CK_STATESAVE_3DENTITYNDATA		= 0x00100000,	// Reserved for future use 
+		 CK_STATESAVE_3DENTITYSKINDATA	= 0x00200000,	// Save Skin data 
+		 CK_STATESAVE_3DENTITYONLY		= 0x003FF000,	// Save only 3dEntity specific datas
+		 CK_STATESAVE_3DENTITYALL		= 0x003FFFFF	// Save All datas for sub-classes
+} CK_STATESAVEFLAGS_3DENTITY;
+										
+//------------------------------------------------										
+// Light								
+typedef enum CK_STATESAVEFLAGS_LIGHT 
+{
+		 CK_STATESAVE_LIGHTDATA			= 0x00400000,	// Save Color,Type,Attenuation,Range and cone
+		 CK_STATESAVE_LIGHTDATA2		= 0x00800000,	// Reserved for future use 
+		 CK_STATESAVE_LIGHTRESERVED1	= 0x01000000,	// Reserved for future use 
+		 CK_STATESAVE_LIGHTRESERVED2	= 0x02000000,	// Reserved for future use 
+		 CK_STATESAVE_LIGHTRESERVED3	= 0x04000000,	// Reserved for future use 
+		 CK_STATESAVE_LIGHTRESERVED4	= 0x08000000,	// Reserved for future use 
+		 CK_STATESAVE_LIGHTONLY			= 0x0FC00000,	// Save only Light specific datas
+		 CK_STATESAVE_LIGHTALL			= 0x0FFFFFFF,	// Save All datas for sub-classes
+// Target Light
+		 CK_STATESAVE_TLIGHTTARGET		= 0x80000000,	// Save Light Target
+		 CK_STATESAVE_TLIGHTRESERVED0	= 0x10000000,	// Reserved for future use 
+		 CK_STATESAVE_TLIGHTRESERVED1	= 0x20000000,	// Reserved for future use 
+		 CK_STATESAVE_TLIGHTRESERVED2	= 0x40000000,	// Reserved for future use 
+		 CK_STATESAVE_TLIGHTONLY		= 0xF0000000,	// Save only Target Light specific datas
+		 CK_STATESAVE_TLIGHTALL			= 0xFFFFFFFF	// Save All datas for sub-classes
+} CK_STATESAVEFLAGS_LIGHT;
+
+//--------------------------------------------------
+// Camera								
+typedef enum CK_STATESAVEFLAGS_CAMERA 
+{
+		 CK_STATESAVE_CAMERAFOV				= 0x00400000,	// Save Camera Field of View
+		 CK_STATESAVE_CAMERAPROJTYPE		= 0x00800000,	// Save Camera projection type
+		 CK_STATESAVE_CAMERAOTHOZOOM		= 0x01000000,	// Save Camera orhographic zoom
+		 CK_STATESAVE_CAMERAASPECT			= 0x02000000,	// Save Camera aspect ration
+		 CK_STATESAVE_CAMERAPLANES			= 0x04000000,	// Save Camera near and far clip planes
+		 CK_STATESAVE_CAMERARESERVED2		= 0x08000000,	// Reserved for future use 
+		 CK_STATESAVE_CAMERAONLY			= 0x0FC00000,	// Save only camera specific datas	
+		 CK_STATESAVE_CAMERAALL				= 0x0FFFFFFF,	// Save All datas for sub-classes	
+// Target Camera
+		 CK_STATESAVE_TCAMERATARGET			= 0x10000000,	// Save camera Target
+		 CK_STATESAVE_TCAMERARESERVED1		= 0x20000000,	// Reserved for future use 
+		 CK_STATESAVE_TCAMERARESERVED2		= 0x40000000,	// Reserved for future use 
+		 CK_STATESAVE_TCAMERAONLY			= 0x70000000,	// Save only Target camera specific datas
+		 CK_STATESAVE_TCAMERAALL			= 0x7FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_CAMERA;
+
+
+//--------------------------------------------------
+// Sprite3D								
+typedef enum CK_STATESAVEFLAGS_SPRITE3D 
+{
+		 CK_STATESAVE_SPRITE3DDATA		= 0x00400000,		// Save offset,mapping,size and material
+		 CK_STATESAVE_SPRITE3DRESERVED0	= 0x00800000,		// Reserved for future use 
+		 CK_STATESAVE_SPRITE3DRESERVED1	= 0x01000000,		// Reserved for future use 
+		 CK_STATESAVE_SPRITE3DRESERVED2	= 0x02000000,		// Reserved for future use 
+		 CK_STATESAVE_SPRITE3DRESERVED3	= 0x04000000,		// Reserved for future use 
+		 CK_STATESAVE_SPRITE3DRESERVED4	= 0x08000000,		// Reserved for future use 
+		 CK_STATESAVE_SPRITE3DONLY		= 0x0FC00000,		// Save only Sprite3D specific datas
+		 CK_STATESAVE_SPRITE3DALL		= 0x0FFFFFFF		// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_SPRITE3D;
+
+//--------------------------------------------------
+// Object 3D								
+typedef enum CK_STATESAVEFLAGS_3DOBJECT 
+{
+		 CK_STATESAVE_3DOBJECTATTRIBUTES	= 0x00400000,	// Obsolete		
+		 CK_STATESAVE_3DOBJECTRESERVED		= 0x00800000,	// Reserved for future use 
+		 CK_STATESAVE_3DOBJECTRONLY			= 0x00C00000,	// Save only 3dObject specific datas
+		 CK_STATESAVE_3DOBJECTALL			= 0x03FFFFFF	// Save All datas for sub-classes			
+} CK_STATESAVEFLAGS_3DOBJECT;
+
+//--------------------------------------------------
+// BodyPart							
+typedef enum CK_STATESAVEFLAGS_BODYPART 
+{
+		 CK_STATESAVE_BODYPARTROTJOINT	= 0x01000000,		// Save rotation joint data
+		 CK_STATESAVE_BODYPARTPOSJOINT	= 0x02000000,		// Save position joint data
+		 CK_STATESAVE_BODYPARTCHARACTER	= 0x04000000,		// Save character owning this bodypart
+		 CK_STATESAVE_BODYPARTRESERVED1	= 0x08000000,		// Reserved for future use 
+		 CK_STATESAVE_BODYPARTRESERVED2	= 0x10000000,		// Reserved for future use 
+		 CK_STATESAVE_BODYPARTRESERVED3	= 0x20000000,		// Reserved for future use 
+		 CK_STATESAVE_BODYPARTRESERVED4	= 0x40000000,		// Reserved for future use 
+		 CK_STATESAVE_BODYPARTONLY		= 0x7F000000,		// Save only bodypart specific datas
+		 CK_STATESAVE_BODYPARTALL		= 0x7FFFFFFF		// Save All datas for sub-classes			
+} CK_STATESAVEFLAGS_BODYPART;
+
+//--------------------------------------------------
+// Character							
+typedef enum CK_STATESAVEFLAGS_CHARACTER 
+{
+		 CK_STATESAVE_CHARACTERBODYPARTS	= 0x00400000,	// Obsolete
+		 CK_STATESAVE_CHARACTERKINECHAINS	= 0x00800000,	// Obsolete
+		 CK_STATESAVE_CHARACTERANIMATIONS	= 0x01000000,	// Obsolete
+		 CK_STATESAVE_CHARACTERROOT			= 0x02000000,	// Obsolete
+		 CK_STATESAVE_CHARACTERSAVEANIMS	= 0x04000000,	// Save current and next active animations
+		 CK_STATESAVE_CHARACTERSAVECHAINS	= 0x08000000,	// Obsolete
+		 CK_STATESAVE_CHARACTERSAVEPARTS	= 0x10000000,	// Save sub bodyparts and sub-bodyparts data (saved with flag :CK_STATESAVE_BODYPARTALL)
+		 CK_STATESAVE_CHARACTERFLOORREF		= 0x20000000,	// Save Character floor reference object
+		 CK_STATESAVE_CHARACTERRESERVED2	= 0x40000000,	// Reserved for future use 
+		 CK_STATESAVE_CHARACTERRESERVED3	= 0x80000000,	// Reserved for future use 
+		 CK_STATESAVE_CHARACTERONLY			= 0xFFC00000,	// Save only character specific datas	
+		 CK_STATESAVE_CHARACTERALL			= 0xFFFFFFFF	// Save All datas for sub-classes			
+} CK_STATESAVEFLAGS_CHARACTER;
+
+//--------------------------------------------------
+// CURVE							
+// && Curve Point							
+typedef enum CK_STATESAVEFLAGS_CURVE 
+{
+		 CK_STATESAVE_CURVEFITCOEFF			= 0x00400000,	// Save fitting coef
+		 CK_STATESAVE_CURVECONTROLPOINT		= 0x00800000,	// Save list of control points
+		 CK_STATESAVE_CURVESTEPS			= 0x01000000,	// Save number of step setting
+		 CK_STATESAVE_CURVEOPEN				= 0x02000000,	// Save Open/Close flag
+		 CK_STATESAVE_CURVERESERVED1		= 0x04000000,	// Reserved for future use 
+		 CK_STATESAVE_CURVERESERVED2		= 0x08000000,	// Reserved for future use 
+// Control points
+		 CK_STATESAVE_CURVEPOINTDEFAULTDATA	= 0x10000000,	// Save Control point setting and position
+		 CK_STATESAVE_CURVEPOINTTCB			= 0x20000000,	// Save Control point tcb settings
+		 CK_STATESAVE_CURVEPOINTTANGENTS	= 0x40000000,	// Save Control point tangents
+		 CK_STATESAVE_CURVEPOINTCURVEPOS	= 0x80000000,	// Save Control point position in curve
+		 CK_STATESAVE_CURVESAVEPOINTS		= 0xFF000000,	// Save control points data 
+		 
+		 CK_STATESAVE_CURVEONLY				= 0xFFC00000,	// Save only curve specific data	
+		 CK_STATESAVE_CURVEALL				= 0xFFFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_CURVE;
+
+//------------------------------------------------									
+// 2dEntity								
+typedef enum CK_STATESAVEFLAGS_2DENTITY 
+{
+		 CK_STATESAVE_2DENTITYSRCSIZE	= 0x00001000,		// Save source size
+		 CK_STATESAVE_2DENTITYSIZE		= 0x00002000,		// Save size
+		 CK_STATESAVE_2DENTITYFLAGS		= 0x00004000,		// Save Flags
+		 CK_STATESAVE_2DENTITYPOS		= 0x00008000,		// Save position
+		 CK_STATESAVE_2DENTITYZORDER    = 0x00100000,		// Save Z order
+		 CK_STATESAVE_2DENTITYONLY		= 0x0010F000,		// Save only 2dEntity specific data 
+		 CK_STATESAVE_2DENTITYMATERIAL  = 0x00200000,		// Save Material
+		 CK_STATESAVE_2DENTITYHIERARCHY	= 0x00400000,		// Save Material
+		 CK_STATESAVE_2DENTITYALL		= 0x0070FFFF		// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_2DENTITY;
+
+//------------------------------------------------									
+// Sprite								
+typedef enum CK_STATESAVEFLAGS_SPRITE 
+{
+		 CK_STATESAVE_SPRITECURRENTIMAGE	= 0x00010000,	// Save current image
+		 CK_STATESAVE_SPRITETRANSPARENT		= 0x00020000,	// Save transparency settings
+		 CK_STATESAVE_SPRITEBITMAPS			= 0x00040000,	// Obsolete	
+		 CK_STATESAVE_SPRITESHARED			= 0x00080000,	// Save shared sprite
+		 CK_STATESAVE_SPRITEDONOTUSE		= 0x00100000,	// Reseved by CK_STATESAVEFLAGS_2DENTITY
+		 CK_STATESAVE_SPRITEAVIFILENAME		= 0x00200000,	// Obsolete	
+		 CK_STATESAVE_SPRITEFILENAMES		= 0x00400000,	// Obsolete
+		 CK_STATESAVE_SPRITECOMPRESSED		= 0x00800000,	// Obsolete
+		 CK_STATESAVE_SPRITEREADER			= 0x10000000,	// Reserved for future use 
+		 CK_STATESAVE_SPRITEFORMAT			= 0x20000000,	// Reserved for future use 
+		 CK_STATESAVE_SPRITEVIDEOFORMAT		= 0x40000000,	// Video Format 
+		 CK_STATESAVE_SPRITESYSTEMCACHING	= 0x80000000,	// System Memory Caching
+		 CK_STATESAVE_SPRITERENDEROPTIONS	= 0x80800000,	// Render options if any...
+		 CK_STATESAVE_SPRITEONLY			= 0xF0EF0000,	// Save only sprite specific data 
+		 CK_STATESAVE_SPRITEALL				= 0x70FFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_SPRITE;
+
+
+//------------------------------------------------									
+// Sprite Text
+typedef enum CK_STATESAVEFLAGS_SPRITETEXT 
+{
+		 CK_STATESAVE_SPRITETEXT			= 0x01000000,	// Save text
+		 CK_STATESAVE_SPRITEFONT			= 0x02000000,	// Save font settings
+		 CK_STATESAVE_SPRITETEXTCOLOR		= 0x04000000,	// Save text color
+		 CK_STATESAVE_SPRITETEXTRESERVED	= 0x08000000,	// Reserved for future use 
+		 CK_STATESAVE_SPRITETEXTDOTNOTUSE	= 0x10000000,	// Reserved by CK_STATESAVE_SPRITEREADER
+		 CK_STATESAVE_SPRITETEXTDONOTUSED2	= 0x20000000,	// Reserved by CK_STATESAVE_SPRITEFORMAT
+		 CK_STATESAVE_SPRITETEXTONLY		= 0x0F000000,	// Save only SpriteText specific data 	
+		 CK_STATESAVE_SPRITETEXTALL			= 0x3FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_SPRITETEXT;
+
+//------------------------------------------------									
+// Sound								
+typedef enum CK_STATESAVEFLAGS_SOUND 
+{
+		 CK_STATESAVE_SOUNDFILENAME		= 0x00001000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED1	= 0x00002000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED2	= 0x00004000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED3	= 0x00008000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED4	= 0x00010000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED5	= 0x00020000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED6	= 0x00040000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDRESERVED7	= 0x00080000,	// Reserved for future use 
+		 CK_STATESAVE_SOUNDONLY			= 0x000FF000,	// Save only Sound specific data 
+		 CK_STATESAVE_SOUNDALL			= 0x000FFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_SOUND;
+
+//------------------------------------------------									
+// Wave Sound								
+typedef enum CK_STATESAVEFLAGS_WAVSOUND 
+{
+		 CK_STATESAVE_WAVSOUNDFILE		= 0x00100000,	// Save sound filename
+		 CK_STATESAVE_WAVSOUNDDATA		= 0x00200000,	// Obsolete
+		 CK_STATESAVE_WAVSOUNDDATA2		= 0x00400000,	// Save sound properties (3D/2D,pitch,gain,streaming,loop,etc..)
+		 CK_STATESAVE_WAVSOUNDDURATION	= 0x00800000,	// Sound Length (in case it cannot be calculated latter)
+		 CK_STATESAVE_WAVSOUNDRESERVED4	= 0x01000000,	// Reserved for future use 
+		 CK_STATESAVE_WAVSOUNDRESERVED5	= 0x02000000,	// Reserved for future use 	
+		 CK_STATESAVE_WAVSOUNDRESERVED6	= 0x04000000,	// Reserved for future use 
+		 CK_STATESAVE_WAVSOUNDRESERVED7	= 0x08000000,	// Reserved for future use 
+		 CK_STATESAVE_WAVSOUNDONLY		= 0x0FF00000,	// Save All datas for sub-classes	
+		 CK_STATESAVE_WAVSOUNDALL		= 0x0FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_WAVSOUND;
+
+
+//------------------------------------------------									
+// Wave Sound								
+typedef enum CK_STATESAVEFLAGS_MIDISOUND 
+{
+		 CK_STATESAVE_MIDISOUNDFILE			= 0x00100000,	// Save sound filename
+		 CK_STATESAVE_MIDISOUNDDATA			= 0x00200000,	// Save midi data 
+		 CK_STATESAVE_MIDISOUNDRESERVED2	= 0x00400000,	// Reserved for future use 
+		 CK_STATESAVE_MIDISOUNDRESERVED3	= 0x00800000,	// Reserved for future use 
+		 CK_STATESAVE_MIDISOUNDRESERVED4	= 0x01000000,	// Reserved for future use 
+		 CK_STATESAVE_MIDISOUNDRESERVED5	= 0x02000000,	// Reserved for future use 
+		 CK_STATESAVE_MIDISOUNDRESERVED6	= 0x04000000,	// Reserved for future use 
+		 CK_STATESAVE_MIDISOUNDRESERVED7	= 0x08000000,	// Reserved for future use 
+		 CK_STATESAVE_MIDISOUNDONLY			= 0x0FF00000,
+		 CK_STATESAVE_MIDISOUNDALL			= 0x0FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_MIDISOUND;
+
+
+//------------------------------------------------									
+// Place								
+typedef enum CK_STATESAVEFLAGS_PLACE 
+{
+		 CK_STATESAVE_PLACEPORTALS			= 0x00001000,	// Save level using the place
+		 CK_STATESAVE_PLACECAMERA			= 0x00002000,	// Save attached camera	
+		 CK_STATESAVE_PLACEREFERENCES		= 0x00004000,	// Save list of objects in the place
+		 CK_STATESAVE_PLACELEVEL			= 0x00008000,	// Save level using the place
+		 CK_STATESAVE_PLACEALL				= 0x0000FFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_PLACE;
+
+//------------------------------------------------									
+// Level
+// CKSaveObjectState will not save any data
+typedef enum CK_STATESAVEFLAGS_LEVEL 
+{
+		 CK_STATESAVE_LEVELRESERVED0	= 0x00001000,	// Reserved for future use 	
+		 CK_STATESAVE_LEVELINACTIVEMAN	= 0x00002000,	// Reserved for future use 	
+		 CK_STATESAVE_LEVELDUPLICATEMAN	= 0x00004000,	// Reserved for future use 	
+		 CK_STATESAVE_LEVELDEFAULTDATA	= 0x20000000,	// Save Places,Scenes and Objects
+		 CK_STATESAVE_LEVELSCENE		= 0x80000000,	// Default and active  scene
+		 CK_STATESAVE_LEVELALL			= 0xFFFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_LEVEL;
+
+
+
+
+//------------------------------------------------									
+// GROUP
+typedef enum CK_STATESAVEFLAGS_GROUP 
+{
+		 CK_STATESAVE_GROUPDATA			= 0x00001000,	// Save list of objects in the group 
+		 CK_STATESAVE_GROUPRESERVED1	= 0x00002000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPRESERVED2	= 0x00004000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPRESERVED3	= 0x00008000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPRESERVED4	= 0x00010000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPRESERVED5	= 0x00020000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPRESERVED6	= 0x00040000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPRESERVED7	= 0x00080000,	// Reserved for future use 
+		 CK_STATESAVE_GROUPALL			= 0x000FFFFF	// Save All datas for sub-classes
+} CK_STATESAVEFLAGS_GROUP;
+
+
+//------------------------------------------------									
+// MESH
+// CKSaveOjectSave will save all data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_MESH 
+{
+		 CK_STATESAVE_MESHRESERVED0		= 0x00001000,	// Reserved for future use 
+		 CK_STATESAVE_MESHFLAGS			= 0x00002000,	// Save flags
+		 CK_STATESAVE_MESHCHANNELS		= 0x00004000,	// Save Channels 
+		 CK_STATESAVE_MESHFACECHANMASK	= 0x00008000,	// Save face channel Mask
+		 CK_STATESAVE_MESHFACES			= 0x00010000,	// Save face data
+		 CK_STATESAVE_MESHVERTICES		= 0x00020000,	// Save geometry
+		 CK_STATESAVE_MESHLINES			= 0x00040000,	// Save line data
+		 CK_STATESAVE_MESHWEIGHTS		= 0x00080000,	// Save Vertex Weight info
+		 CK_STATESAVE_MESHMATERIALS		= 0x00100000,	// Reserved for future use 
+		 CK_STATESAVE_MESHRESERVED1		= 0x00200000,	// Reserved for future use 
+		 CK_STATESAVE_MESHRESERVED2		= 0x00400000,	// Reserved for future use 
+		 CK_STATESAVE_PROGRESSIVEMESH	= 0x00800000,	// Save All datas for sub-classes	
+		 CK_STATESAVE_MESHONLY			= 0x00FFF000,	// Save All datas for sub-classes	
+		 CK_STATESAVE_MESHALL			= 0x00FFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_MESH;
+
+
+//------------------------------------------------									
+// PATCH MESH
+// CKSaveOjectSave will save all data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_PATCHMESH 
+{
+		 CK_STATESAVE_PATCHMESHDATA			= 0x00800000,	// Obsolete
+		 CK_STATESAVE_PATCHMESHDATA2		= 0x01000000,	// Obsolete
+		 CK_STATESAVE_PATCHMESHSMOOTH		= 0x02000000,	// Obsolete
+		 CK_STATESAVE_PATCHMESHMATERIALS	= 0x04000000,	// Obsolete
+		 CK_STATESAVE_PATCHMESHDATA3		= 0x08000000,	// Save Patch Data
+		 CK_STATESAVE_PATCHMESHONLY			= 0x0FF00000,	// Save All datas for sub-classes	
+		 CK_STATESAVE_PATCHMESHALL			= 0x0FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_PATCHMESH;
+
+//-------------------------------------------------									
+// Material
+typedef enum CK_STATESAVEFLAGS_MATERIAL 
+{
+		 CK_STATESAVE_MATDATA			= 0x00001000,	// Save colors,blending modes,shade modes,fill modes etc...
+		 CK_STATESAVE_MATDATA2			= 0x00002000,	// Additional texture objects...
+		 CK_STATESAVE_MATDATA3			= 0x00004000,	// Effect Alone
+		 CK_STATESAVE_MATDATA4			= 0x00008000,	// none
+		 CK_STATESAVE_MATDATA5			= 0x00010000,	// Effect + parameter 
+		 CK_STATESAVE_MATRESERVED5		= 0x00020000,	// Reserved for future use 
+		 CK_STATESAVE_MATRESERVED6		= 0x00040000,	// Reserved for future use 
+		 CK_STATESAVE_MATRESERVED7		= 0x00080000,	// Reserved for future use		
+		 CK_STATESAVE_MATERIALONLY		= 0x000FF000,	// Save All datas for sub-classes	
+		 CK_STATESAVE_MATERIALALL		= 0x0FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_MATERIAL;
+
+//---------------------------------------------------									
+// Texture
+// CKSaveOjectSave will save all relevant data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_TEXTURE 
+{
+		 CK_STATESAVE_TEXAVIFILENAME	= 0x00001000,	// Save movie file name
+		 CK_STATESAVE_TEXCURRENTIMAGE	= 0x00002000,	// Save current slot	
+		 CK_STATESAVE_TEXBITMAPS		= 0x00004000,	// Obsolete
+		 CK_STATESAVE_TEXTRANSPARENT	= 0x00008000,	// Save transparency data
+		 CK_STATESAVE_TEXFILENAMES		= 0x00010000,	// Save texture slot filenames
+		 CK_STATESAVE_TEXCOMPRESSED		= 0x00020000,	// Save raw texture data	
+		 CK_STATESAVE_TEXVIDEOFORMAT	= 0x00040000,	// Save chosen video format
+		 CK_STATESAVE_TEXSAVEFORMAT		= 0x00080000,	// Save chosen save format
+		 CK_STATESAVE_TEXREADER			= 0x00100000,	// Save texture data using a specific BitmapReader
+		 CK_STATESAVE_PICKTHRESHOLD		= 0x00200000,	// Save pick threshold
+		 CK_STATESAVE_USERMIPMAP		= 0x00400000,	// User mipmap levels
+		 CK_STATESAVE_TEXSYSTEMCACHING	= 0x00800000,	// System Memory Caching
+		 CK_STATESAVE_OLDTEXONLY		= 0x002FF000,	// Kept for compatibility 
+		 CK_STATESAVE_TEXONLY			= 0x00FFF000,	// Save Only Texture Data (Dot NOT MODIFY ! Texture loading/saving relies on this value)
+		 CK_STATESAVE_TEXALL			= 0x002FFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_TEXTURE;
+
+
+//---------------------------------------------------
+// 2d CURVE							
+// && 2d Curve Point							
+typedef enum CK_STATESAVEFLAGS_2DCURVE 
+{
+		 CK_STATESAVE_2DCURVERESERVED0		 = 0x00000010,	// Reserved for future use 
+		 CK_STATESAVE_2DCURVERESERVED4		 = 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_2DCURVEFITCOEFF		 = 0x00000040,	// Obsolete
+		 CK_STATESAVE_2DCURVECONTROLPOINT	 = 0x00000080,	// Obsolete
+		 CK_STATESAVE_2DCURVENEWDATA		 = 0x00000100,	// Save All relevant data	
+		 CK_STATESAVE_2DCURVERESERVED2		 = 0x00000200,	// Obsolete
+		 CK_STATESAVE_2DCURVERESERVED3		 = 0x00000400,	// Obsolete
+		 CK_STATESAVE_2DCURVEPOINTTCB		 = 0x00000800,	// Obsolete
+		 CK_STATESAVE_2DCURVEPOINTTANGENTS	 = 0x00001000,	// Obsolete
+		 CK_STATESAVE_2DCURVEPOINT2DCURVEPOS = 0x00002000,	// Obsolete
+		 CK_STATESAVE_2DCURVEPOINTDEFAULTDATA= 0x00004000,	// Obsolete
+		 CK_STATESAVE_2DCURVEPOINTNEWDATA	 = 0x00008000,	// Save All relevant data	
+		 CK_STATESAVE_2DCURVEPOINTRESERVED1	 = 0x00010000,	// Reserved for future use 
+		 CK_STATESAVE_2DCURVEPOINTRESERVED2	 = 0x00020000,	// Reserved for future use 
+		 CK_STATESAVE_2DCURVESAVEPOINTS		 = 0x0003F800,	// Obsolete
+		 CK_STATESAVE_2DCURVEALL			 = 0x0007FFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_2DCURVE;
+
+//---------------------------------------------------
+// Kinematic Chain
+
+typedef enum CK_STATESAVEFLAGS_KINEMATICCHAIN 
+{
+		 CK_STATESAVE_KINEMATICCHAINDATA	  = 0x00000010,	// Save chain data
+		 CK_STATESAVE_KINEMATICCHAINRESERVED1 = 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_KINEMATICCHAINRESERVED2 = 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_KINEMATICCHAINRESERVED3 = 0x00000080,	// Reserved for future use 
+		 CK_STATESAVE_KINEMATICCHAINALL		  = 0x000000FF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_KINEMATICCHAIN;
+
+//---------------------------------------------------
+// Animation
+typedef enum CK_STATESAVEFLAGS_ANIMATION 
+{
+		 CK_STATESAVE_ANIMATIONDATA				= 0x00000010,	// Save Flags & Framerate data
+		 CK_STATESAVE_ANIMATIONRESERVED1		= 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_ANIMATIONLENGTH			= 0x00000040,	// Save animation Length
+		 CK_STATESAVE_ANIMATIONBODYPARTS		= 0x00000080,	// Save root & list of bodypart
+		 CK_STATESAVE_ANIMATIONCHARACTER		= 0x00000100,	// Save character	
+		 CK_STATESAVE_ANIMATIONCURRENTSTEP		= 0x00000200,	// Save current step
+		 CK_STATESAVE_ANIMATIONRESERVED5		= 0x00000400,	// Reserved for future use 
+		 CK_STATESAVE_ANIMATIONRESERVED6		= 0x00000800,	// Reserved for future use 
+		 CK_STATESAVE_ANIMATIONALL				= 0x0FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_ANIMATION;
+
+//---------------------------------------------------
+// Keyed Anim
+typedef enum CK_STATESAVEFLAGS_KEYEDANIMATION 
+{
+		 CK_STATESAVE_KEYEDANIMANIMLIST		= 0x00001000,	// Save list of object animations
+		 CK_STATESAVE_KEYEDANIMLENGTH		= 0x00002000,	// Obsolete	
+		 CK_STATESAVE_KEYEDANIMPOSKEYS		= 0x00004000,	// Obsolete
+		 CK_STATESAVE_KEYEDANIMROTKEYS		= 0x00008000,	// Obsolete	
+		 CK_STATESAVE_KEYEDANIMMORPHKEYS	= 0x00010000,	// Obsolete
+		 CK_STATESAVE_KEYEDANIMSCLKEYS		= 0x00020000,	// Obsolete
+		 CK_STATESAVE_KEYEDANIMFLAGS		= 0x00040000,	// Obsolete
+		 CK_STATESAVE_KEYEDANIMENTITY		= 0x00080000,	// Obsolete
+		 CK_STATESAVE_KEYEDANIMMERGE		= 0x00100000,	// Save merged animations
+		 CK_STATESAVE_KEYEDANIMSUBANIMS		= 0x00200000,	// Save object animations data (using same flags than CKSaveObjectState)
+		 CK_STATESAVE_KEYEDANIMRESERVED0	= 0x00400000,	// Reserved for future use 
+		 CK_STATESAVE_KEYEDANIMRESERVED1	= 0x00800000,	// Reserved for future use 
+		 CK_STATESAVE_KEYEDANIMRESERVED2	= 0x01000000,	// Reserved for future use 
+		 CK_STATESAVE_KEYEDANIMRESERVED3	= 0x02000000	// Reserved for future use 	
+} CK_STATESAVEFLAGS_KEYEDANIMATION;
+
+
+//---------------------------------------------------
+// Object Animation
+// CKSaveOjectSave will save all relevant data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_OBJECTANIMATION 
+{
+		 CK_STATESAVE_OBJANIMNEWDATA		= 0x00001000,	// Save all relevant data
+		 CK_STATESAVE_OBJANIMLENGTH			= 0x00002000,	// Not used
+		 CK_STATESAVE_OBJANIMPOSKEYS		= 0x00004000,	// Not used
+		 CK_STATESAVE_OBJANIMROTKEYS		= 0x00008000,	// Not used
+		 CK_STATESAVE_OBJANIMMORPHKEYS		= 0x00010000,	// Not used
+		 CK_STATESAVE_OBJANIMSCLKEYS		= 0x00020000,	// Not used
+		 CK_STATESAVE_OBJANIMFLAGS			= 0x00040000,	// Not used
+		 CK_STATESAVE_OBJANIMENTITY			= 0x00080000,	// Not used
+		 CK_STATESAVE_OBJANIMMERGE			= 0x00100000,	// Not used
+		 CK_STATESAVE_OBJANIMMORPHKEYS2		= 0x00200000,	// Not used
+		 CK_STATESAVE_OBJANIMNEWSAVE1		= 0x00400000,	// Not used
+		 CK_STATESAVE_OBJANIMMORPHNORMALS	= 0x00800000,	// Not used (Virtools 1.1)
+		 CK_STATESAVE_OBJANIMMORPHCOMP		= 0x01000000,	// Not used (Virtools 1.1)
+		 CK_STATESAVE_OBJANIMSHARED			= 0x02000000,	// Save Data for a shared animation
+		 CK_STATESAVE_OBJANIMCONTROLLERS	= 0x04000000,	// (Virtools 1.5) Save All Controller information
+		 CK_STATESAVE_OBJANIMONLY			= 0x07FFF000,
+		 CK_STATESAVE_OBJANIMALL			= 0x07FFFFFF,
+		 CK_STATESAVE_KEYEDANIMONLY			= 0x03FFF000,	// Save All datas for sub-classes	
+		 CK_STATESAVE_KEYEDANIMALL			= 0x03FFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_OBJECTANIMATION;
+
+
+//---------------------------------------------------
+// IK Animation
+typedef enum CK_STATESAVEFLAGS_IKANIMATION 
+{
+		 CK_STATESAVE_IKANIMATIONDATA		= 0x00001000,	// Save IK data
+		 CK_STATESAVE_IKANIMATIONRESERVED2	= 0x00002000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED3	= 0x00004000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED4	= 0x00008000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED5	= 0x00010000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED6	= 0x00020000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED7	= 0x00040000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED8	= 0x00100000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONRESERVED9	= 0x00200000,	// Reserved for future use 
+		 CK_STATESAVE_IKANIMATIONALL		= 0x003FFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_IKANIMATION;
+
+//---------------------------------------------------
+// BehaviorLink
+typedef enum CK_STATESAVEFLAGS_BEHAV_LINK 
+{
+		 CK_STATESAVE_BEHAV_LINK_CURDELAY	= 0x00000004,	// Obsolete
+		 CK_STATESAVE_BEHAV_LINK_IOS		= 0x00000008,	// Obsolete
+		 CK_STATESAVE_BEHAV_LINK_DELAY		= 0x00000010,	// Obsolete	
+		 CK_STATESAVE_BEHAV_LINK_NEWDATA	= 0x00000020,	// Save all relevant data (In,Out,Activation delay)	
+		 CK_STATESAVE_BEHAV_LINKRESERVED5	= 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_BEHAV_LINKRESERVED6	= 0x00000080,	// Reserved for future use 
+		 CK_STATESAVE_BEHAV_LINKONLY		= 0x000000F0,	// 
+		 CK_STATESAVE_BEHAV_LINKALL			= 0x000000FF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_BEHAV_LINK;
+
+//---------------------------------------------------
+// BehaviorIO
+typedef enum CK_STATESAVEFLAGS_BEHAV_IO 
+{
+		 CK_STATESAVE_BEHAV_IOFLAGS			= 0x00000008,	// Save IO flags	
+		 CK_STATESAVE_BEHAV_IORESERVED3		= 0x00000010,	// Reserved for future use 
+		 CK_STATESAVE_BEHAV_IORESERVED4		= 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_BEHAV_IORESERVED5		= 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_BEHAV_IORESERVED6		= 0x00000080,	// Reserved for future use 
+		 CK_STATESAVE_BEHAVIOONLY			= 0x000000F0,	// 
+		 CK_STATESAVE_BEHAVIOALL			= 0x000000FF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_BEHAV_IO;
+										
+//---------------------------------------------------
+// BehaviorPrototype
+typedef enum CK_STATESAVEFLAGS_PROTOTYPE 
+{
+		 CK_STATESAVE_PROTORESERVED0		= 0x00000010,	// Reserved for future use 
+		 CK_STATESAVE_PROTORESERVED1		= 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_PROTOFLAGS			= 0x00000040,	// Save Flags
+		 CK_STATESAVE_PROTOSUBPROTOS		= 0x00000080,	// Save sub prototypes
+		 CK_STATESAVE_PROTOLINKS			= 0x00000100,	// Save links	
+		 CK_STATESAVE_PROTOBEHAVFLAG		= 0x00000200,	// Save behavior flags
+		 CK_STATESAVE_PROTOGUID				= 0x00000400,	// Save GUID
+		 CK_STATESAVE_PROTOINPUTS			= 0x00000800,	// Save inputs
+		 CK_STATESAVE_PROTOOUTPUTS			= 0x00001000,	// Save outputs
+		 CK_STATESAVE_PROTOINPARAMS			= 0x00002000,	// Save input parameters
+		 CK_STATESAVE_PROTOOUTPARAMS		= 0x00004000,	// Save output parameters
+		 CK_STATESAVE_PROTOLOCALPARAMS		= 0x00008000,	// Save local parameters
+		 CK_STATESAVE_PROTOOPERATIONS		= 0x00010000,	// Save parameter operations
+		 CK_STATESAVE_PROTOPARAMETERLINKS	= 0x00020000,	// Save parameter links
+		 CK_STATESAVE_PROTOAPPLYTO			= 0x00040000,	// Save ClassID of object to which it applies
+		 CK_STATESAVE_PROTORESERVED14		= 0x00080000,	// Reserved for future use 
+		 CK_STATESAVE_PROTOALL				= 0x000FFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_PROTOTYPE;
+										
+
+//---------------------------------------------------
+// Behavior
+typedef enum CK_STATESAVEFLAGS_BEHAVIOR 
+{
+		 CK_STATESAVE_BEHAVIORRESERVED0		= 0x00000010,	// Reserved for internal use
+		 CK_STATESAVE_BEHAVIORNEWDATA		= 0x00000020,	// not used
+		 CK_STATESAVE_BEHAVIORFLAGS			= 0x00000040,	// not used
+		 CK_STATESAVE_BEHAVIORCOMPATIBLECID	= 0x00000080,	// not used
+		 CK_STATESAVE_BEHAVIORSUBBEHAV		= 0x00000100,	// Save Sub-Behaviors
+		 CK_STATESAVE_BEHAVIORINPARAMS		= 0x00000200,	// not used
+		 CK_STATESAVE_BEHAVIOROUTPARAMS		= 0x00000400,	// not used
+		 CK_STATESAVE_BEHAVIORINPUTS		= 0x00000800,	// not used
+		 CK_STATESAVE_BEHAVIOROUTPUTS		= 0x00001000,	// not used
+		 CK_STATESAVE_BEHAVIORINFO			= 0x00002000,	// not used
+		 CK_STATESAVE_BEHAVIOROPERATIONS	= 0x00004000,	// not used
+		 CK_STATESAVE_BEHAVIORTYPE			= 0x00008000,	// not used
+		 CK_STATESAVE_BEHAVIOROWNER			= 0x00010000,	// not used
+		 CK_STATESAVE_BEHAVIORLOCALPARAMS	= 0x00020000,	// Save local parameters
+		 CK_STATESAVE_BEHAVIORPROTOGUID		= 0x00040000,	// not used
+		 CK_STATESAVE_BEHAVIORSUBLINKS		= 0x00080000,	// not used
+		 CK_STATESAVE_BEHAVIORACTIVESUBLINKS= 0x00100000,	// not used
+		 CK_STATESAVE_BEHAVIORSINGLEACTIVITY= 0x00200000,	// SINGLE ACTIVITY
+		 CK_STATESAVE_BEHAVIORSCRIPTDATA	= 0x00400000,	// not used
+		 CK_STATESAVE_BEHAVIORPRIORITY		= 0x00800000,	// not used
+		 CK_STATESAVE_BEHAVIORTARGET		= 0x01000000,	// not used
+		 CK_STATESAVE_BEHAVIORONLY			= 0x01FFFFF0,	
+		 CK_STATESAVE_BEHAVIORALL			= 0x01FFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_BEHAVIOR;
+
+
+
+
+//---------------------------------------------------
+// SCENE 
+// CKSaveOjectSave will save all relevant data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_SCENE 
+{
+		 CK_STATESAVE_SCENERESERVED0			= 0x00001000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED8			= 0x00002000,	// Reserved for future use 
+		 CK_STATESAVE_SCENEFLAGS				= 0x00004000,	
+		 CK_STATESAVE_SCENELEVEL				= 0x00008000,	
+		 CK_STATESAVE_SCENEOBJECTS				= 0x00010000,
+		 CK_STATESAVE_SCENENEWDATA				= 0x00020000,	// every object description and initial conditions
+		 CK_STATESAVE_SCENELAUNCHED				= 0x00040000,	// Scene was already launched once	
+		 CK_STATESAVE_SCENERENDERSETTINGS		= 0x00080000,	// Background Color, Fog Color etc..
+		 CK_STATESAVE_SCENERESERVED1			= 0x00100000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED2			= 0x00200000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED3			= 0x00400000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED4			= 0x00800000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED5			= 0x01000000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED12			= 0x02000000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED13			= 0x04000000,	// Reserved for future use 
+		 CK_STATESAVE_SCENERESERVED14			= 0x08000000,	// Reserved for future use 
+		 CK_STATESAVE_SCENEALL					= 0x0FFFFFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_SCENE;
+
+
+//---------------------------------------------------
+// ParameterIn
+typedef enum CK_STATESAVEFLAGS_PARAMETERIN 
+{
+		 CK_STATESAVE_PARAMETERIN_RESERVED4		= 0x00000010,	// Reserved for future use 
+		 CK_STATESAVE_PARAMETERIN_RESERVED0		= 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_PARAMETERIN_RESERVED1		= 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_PARAMETERIN_OWNER			= 0x00000080,	// Obsolete
+		 CK_STATESAVE_PARAMETERIN_INSHARED		= 0x00000100,	// Obsolete
+		 CK_STATESAVE_PARAMETERIN_OUTSOURCE		= 0x00000200,	// Obsolete
+		 CK_STATESAVE_PARAMETERIN_DEFAULTDATA	= 0x00000400,	// Obsolete
+		 CK_STATESAVE_PARAMETERIN_DATASHARED	= 0x00000800,	// Save reference to shared inparameter
+		 CK_STATESAVE_PARAMETERIN_DATASOURCE	= 0x00001000,	// Save reference to source outparameter
+		 CK_STATESAVE_PARAMETERIN_DISABLED		= 0x00002000,	// The parameter was disabled
+		 CK_STATESAVE_PARAMETERIN_ALL			= 0x0000FFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_PARAMETERIN;
+
+//---------------------------------------------------
+// ParameterLocal et ParameterOut
+typedef enum CK_STATESAVEFLAGS_PARAMETEROUT 
+{
+		 CK_STATESAVE_PARAMETEROUT_RESERVED0		= 0x00000010,	// Reserved for future use 
+		 CK_STATESAVE_PARAMETEROUT_DESTINATIONS		= 0x00000020,	// Save destinations 
+		 CK_STATESAVE_PARAMETEROUT_VAL				= 0x00000040,	// Save value
+		 CK_STATESAVE_PARAMETEROUT_OWNER			= 0x00000080,	// Save Owner
+		 CK_STATESAVE_PARAMETEROUT_MYSELF			= 0x00000200,	// 	
+		 CK_STATESAVE_PARAMETEROUT_ISSETTING		= 0x00000400,	// Reserved for future use 
+		 CK_STATESAVE_PARAMETEROUT_ALL				= 0x0000FFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_PARAMETEROUT;
+
+
+//---------------------------------------------------
+// Parameter Operation
+
+typedef enum CK_STATESAVEFLAGS_OPERATION 
+{
+		 CK_STATESAVE_OPERATIONRESERVED0		= 0x00000010,	// Reserved for future use 
+		 CK_STATESAVE_OPERATIONRESERVED1		= 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_OPERATIONINPUTS			= 0x00000040,
+		 CK_STATESAVE_OPERATIONOUTPUT			= 0x00000080,
+		 CK_STATESAVE_OPERATIONOP				= 0x00000100,
+		 CK_STATESAVE_OPERATIONDEFAULTDATA		= 0x00000200,
+		 CK_STATESAVE_OPERATIONNEWDATA			= 0x00000400,
+		 CK_STATESAVE_OPERATIONALL				= 0x000007FF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_OPERATION;
+
+
+//---------------------------------------------------
+// Synchro Object
+// CKSaveOjectSave will save all relevant data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_SYNCHRO 
+{
+		 CK_STATESAVE_SYNCHRODATA				= 0x00000010,	// Save data
+		 CK_STATESAVE_SYNCHRORESERVED0			= 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_SYNCHRORESERVED1			= 0x00000080,	// Reserved for future use 
+		 CK_STATESAVE_SYNCHRORESERVED2			= 0x00000100,	// Reserved for future use 
+		 CK_STATESAVE_SYNCHRORESERVED3			= 0x00000200,	// Reserved for future use 
+		 CK_STATESAVE_SYNCHRONALL				= 0x000003FF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_SYNCHRO;
+
+//------------------------------------------------										
+// Grid								
+typedef enum CK_STATESAVEFLAGS_GRID 
+{
+		 CK_STATESAVE_GRIDDATA		= 0x00400000,		// Save Grid Data
+		 CK_STATESAVE_GRIDRESERVED0	= 0x00800000,		// Reserved for future use 
+		 CK_STATESAVE_GRIDRESERVED1	= 0x01000000,		// Reserved for future use 
+		 CK_STATESAVE_GRIDRESERVED2	= 0x02000000,		// Reserved for future use 
+		 CK_STATESAVE_GRIDRESERVED3	= 0x04000000,		// Reserved for future use 
+		 CK_STATESAVE_GRIDRESERVED4	= 0x08000000,		// Reserved for future use 
+		 CK_STATESAVE_GRIDONLY		= 0x0FC00000,		// 
+		 CK_STATESAVE_GRIDALL		= 0x0FFFFFFF		// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_GRID;
+
+
+//------------------------------------------------										
+// Layer (For Grids)
+typedef enum CK_STATESAVEFLAGS_LAYER 
+{
+		 CK_STATESAVE_LAYERDATA			= 0x00000010,	// Save Layer Data
+		 CK_STATESAVE_LAYERRESERVED0	= 0x00800020,	// Reserved for future use 
+		 CK_STATESAVE_LAYERRESERVED1	= 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_LAYERRESERVED2	= 0x00000080,	// Reserved for future use 
+		 CK_STATESAVE_LAYERRESERVED3	= 0x00000100,	// Reserved for future use 
+		 CK_STATESAVE_LAYERRESERVED4	= 0x00000200,	// Reserved for future use 
+		 CK_STATESAVE_LAYERONLY			= 0x000003F0,	// 
+		 CK_STATESAVE_LAYERALL			= 0x000003FF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_LAYER;
+
+//------------------------------------------------									
+// DataArray
+// CKSaveOjectSave will save all relevant data and does not take flags into account
+typedef enum CK_STATESAVEFLAGS_DATAARRAY
+{
+		 CK_STATESAVE_DATAARRAYFORMAT	= 0x00001000,	// Save format
+		 CK_STATESAVE_DATAARRAYDATA		= 0x00002000,	// Save array data
+		 CK_STATESAVE_DATAARRAYMEMBERS	= 0x00004000,	// Save members
+		 CK_STATESAVE_DATAARRAYALL		= 0x0000FFFF	// Save All datas for sub-classes	
+} CK_STATESAVEFLAGS_DATAARRAY;
+
+
+//------------------------------------------------
+// SceneObjectDesc	
+typedef enum CK_STATESAVEFLAGS_SCENEOBJECTDESC {
+
+		 CK_STATESAVE_SCENEOBJECTDESC		= 0x00000010,
+		 CK_STATESAVE_SCENEOBJECTRES1		= 0x00000020,	// Reserved for future use 
+		 CK_STATESAVE_SCENEOBJECTRES2		= 0x00000040,	// Reserved for future use 
+		 CK_STATESAVE_SCENEOBJECTRES3		= 0x00000080,	// Reserved for future use 
+		 CK_STATESAVE_SCENEOBJECTDESCALL	= 0x000000FF	// Save All datas for sub-classes	
+
+} CK_STATESAVEFLAGS_SCENEOBJECTDESC;

Assets/CodeGen/EnumsMigration/src/VxEnums.txt

@@ -0,0 +1,375 @@
+
+/*****************************************************************
+{filename:VX_PIXELFORMAT}
+Name: VX_PIXELFORMAT
+
+Summary: Pixel format types. 
+See Also: VxImageDesc2PixelFormat,VxPixelFormat2ImageDesc
+******************************************************************/
+typedef enum VX_PIXELFORMAT {
+	UNKNOWN_PF	  = 0,			// Unknown pixel format
+	_32_ARGB8888  = 1,			// 32-bit ARGB pixel format with alpha
+	_32_RGB888	  = 2,			// 32-bit RGB pixel format without alpha
+	_24_RGB888	  = 3,			// 24-bit RGB pixel format
+	_16_RGB565	  = 4,			// 16-bit RGB pixel format
+	_16_RGB555	  = 5,			// 16-bit RGB pixel format (5 bits per color)
+	_16_ARGB1555  = 6,			// 16-bit ARGB pixel format (5 bits per color + 1 bit for alpha)
+	_16_ARGB4444  = 7,			// 16-bit ARGB pixel format (4 bits per color)	
+	_8_RGB332     = 8,			// 8-bit  RGB pixel format
+	_8_ARGB2222   = 9,			// 8-bit  ARGB pixel format
+	_32_ABGR8888  = 10,			// 32-bit ABGR pixel format
+	_32_RGBA8888  = 11,			// 32-bit RGBA pixel format
+	_32_BGRA8888  = 12,			// 32-bit BGRA pixel format
+	_32_BGR888	  = 13,			// 32-bit BGR pixel format
+	_24_BGR888	  = 14,			// 24-bit BGR pixel format
+	_16_BGR565	  = 15,			// 16-bit BGR pixel format
+	_16_BGR555	  = 16,			// 16-bit BGR pixel format (5 bits per color)
+	_16_ABGR1555  = 17,			// 16-bit ABGR pixel format (5 bits per color + 1 bit for alpha)
+	_16_ABGR4444  = 18,			// 16-bit ABGR pixel format (4 bits per color)	
+	_DXT1		  = 19,			// S3/DirectX Texture Compression 1	
+	_DXT2		  = 20,			// S3/DirectX Texture Compression 2	
+	_DXT3		  = 21,			// S3/DirectX Texture Compression 3	
+	_DXT4		  = 22,			// S3/DirectX Texture Compression 4	
+	_DXT5		  = 23,			// S3/DirectX Texture Compression 5	
+	_16_V8U8	  = 24,			// 16-bit Bump Map format format (8 bits per color)	
+	_32_V16U16	  = 25,			// 32-bit Bump Map format format (16 bits per color)	
+	_16_L6V5U5	  = 26,			// 16-bit Bump Map format format with luminance
+	_32_X8L8V8U8  = 27,			// 32-bit Bump Map format format with luminance
+	_8_ABGR8888_CLUT  = 28,		// 8 bits indexed CLUT (ABGR)
+	_8_ARGB8888_CLUT  = 29,		// 8 bits indexed CLUT (ARGB)
+	_4_ABGR8888_CLUT  = 30,		// 4 bits indexed CLUT (ABGR)
+	_4_ARGB8888_CLUT  = 31		// 4 bits indexed CLUT (ARGB)
+} VX_PIXELFORMAT;
+
+
+/******************************************************************
+{filename:VXLIGHT_TYPE}
+Summary: Light type.
+
+Remarks:
+	+ Used by CKLight::SetType to specify the type of a light. 
+See also: CKLight::SetType,CKLight::GetType
+******************************************************************/
+typedef enum VXLIGHT_TYPE
+{
+	VX_LIGHTPOINT =	1UL,	//	The Light is a point of light
+	VX_LIGHTSPOT  =	2UL,	//	The light is a spotlight
+	VX_LIGHTDIREC =	3UL,	//	The light is directional light : Lights comes from an infinite point so only direction of light can be given
+	VX_LIGHTPARA  =	4UL	// 	Obsolete, do not use
+} VXLIGHT_TYPE;
+
+
+
+/*****************************************************************
+{filename:VXTEXTURE_BLENDMODE}
+  Summary: Blend Mode Flags
+
+Remarks:
++ The VXTEXTURE_BLENDMODE is used by CKMaterial::SetTextureBlendMode() to specify how
+texture is applied on primitives.
++ Also used as value for CKRST_TSS_TEXTUREMAPBLEND texture stage state. 
+See Also: Using Materials,CKMaterial,CKTexture,CKMaterial::SetTextureBlendMode,CKRST_TSS_TEXTUREMAPBLEND.
+******************************************************************/
+typedef enum VXTEXTURE_BLENDMODE
+{
+	VXTEXTUREBLEND_DECAL			= 1UL,	// Texture replace any material information
+    VXTEXTUREBLEND_MODULATE			= 2UL,	// Texture and material are combine. Alpha information of the texture replace material alpha component.
+    VXTEXTUREBLEND_DECALALPHA		= 3UL,	// Alpha information in the texture specify how material and texture are combined. Alpha information of the texture replace material alpha component. 
+    VXTEXTUREBLEND_MODULATEALPHA	= 4UL,    // Alpha information in the texture specify how material and texture are combined
+    VXTEXTUREBLEND_DECALMASK		= 5UL, 
+    VXTEXTUREBLEND_MODULATEMASK		= 6UL, 
+    VXTEXTUREBLEND_COPY				= 7UL,	// Equivalent to DECAL
+    VXTEXTUREBLEND_ADD				= 8UL,		
+	VXTEXTUREBLEND_DOTPRODUCT3		= 9UL,	// Perform a Dot Product 3 between texture (normal map)
+											// and a referential vector given in VXRENDERSTATE_TEXTUREFACTOR.
+	VXTEXTUREBLEND_MAX				= 10UL,
+	VXTEXTUREBLEND_MASK				= 0xFUL
+} VXTEXTURE_BLENDMODE; 
+
+
+/******************************************************************
+{filename:VXTEXTURE_FILTERMODE}
+  Summary: Filter Mode Options
+
+Remarks:
++ The VXTEXTURE_FILTERMODE is used by CKMaterial::SetTextureMagMode and CKMaterial::SetTextureMinMode to specify how
+texture is filtered when magnified.
++ Also used as value for CKRST_TSS_MAGFILTER and CKRST_TSS_MINFILTER texture stage state. 
+See Also: Using Materials,CKMaterial,CKTexture,CKMaterial::SetTextureMagMode,CKMaterial::SetTextureMinMode,,CKRenderContext::SetTextureStageState
+******************************************************************/
+typedef enum VXTEXTURE_FILTERMODE
+{
+	VXTEXTUREFILTER_NEAREST          = 1UL,		// No Filter 	
+    VXTEXTUREFILTER_LINEAR           = 2UL,		// Bilinear Interpolation
+    VXTEXTUREFILTER_MIPNEAREST       = 3UL,		// Mip mapping 
+    VXTEXTUREFILTER_MIPLINEAR        = 4UL,		// Mip Mapping with Bilinear interpolation
+    VXTEXTUREFILTER_LINEARMIPNEAREST = 5UL,		// Mip Mapping with Bilinear interpolation between mipmap levels.
+    VXTEXTUREFILTER_LINEARMIPLINEAR  = 6UL,		// Trilinear Filtering
+	VXTEXTUREFILTER_ANISOTROPIC		 = 7UL,		// Anisotropic filtering 
+	VXTEXTUREFILTER_MASK			 = 0xFUL
+} VXTEXTURE_FILTERMODE; 
+
+/******************************************************************
+{filename:VXBLEND_MODE}
+Summary: Blending Mode options
+
+Remarks:
+	+ The VXBLEND_MODE is used by CKMaterial::SetSourceBlend() and SetDestBlend() to specify the blend 
+factors that are used when blending is enabled. (Rs,Gs,Bs,As) are color components of the source pixel (being drawn) and
+(Rd,Gd,Bd,Ad) are color components of the destination pixel (current pixel on screen).
+When blending is enabled the final pixel will be equal to : 
+		
+		  SrcBlendFactor * SrcPixel + DstBlendFactor * CurrentPixelOnScreen
+
+	+ Also used as value for VXRENDERSTATE_SRCBLEND and VXRENDERSTATE_DESTBLEND render state. 
+
+See Also: CKMaterial,CKTexture,CKMaterial::SetSourceBlend,CKMaterial::SetDestBlend,CKRenderContext::SetState,CKSprite::SetBlending,VXRENDERSTATE_SRCBLEND,VXRENDERSTATE_DESTBLEND
+******************************************************************/
+typedef enum VXBLEND_MODE
+{
+	VXBLEND_ZERO            = 1UL,		//Blend factor is (0, 0, 0, 0).
+    VXBLEND_ONE             = 2UL,		//Blend factor is (1, 1, 1, 1).
+    VXBLEND_SRCCOLOR        = 3UL,		//Blend factor is (Rs, Gs, Bs, As).
+    VXBLEND_INVSRCCOLOR     = 4UL,		//Blend factor is (1-Rs, 1-Gs, 1-Bs, 1-As).
+    VXBLEND_SRCALPHA        = 5UL,		//Blend factor is (As, As, As, As).
+    VXBLEND_INVSRCALPHA     = 6UL,		//Blend factor is (1-As, 1-As, 1-As, 1-As).
+    VXBLEND_DESTALPHA       = 7UL,		//Blend factor is (Ad, Ad, Ad, Ad).
+    VXBLEND_INVDESTALPHA    = 8UL,		//Blend factor is (1-Ad, 1-Ad, 1-Ad, 1-Ad).
+    VXBLEND_DESTCOLOR       = 9UL,		//Blend factor is (Rd, Gd, Bd, Ad).
+    VXBLEND_INVDESTCOLOR    = 10UL,		//Blend factor is (1-Rd, 1-Gd, 1-Bd, 1-Ad).
+    VXBLEND_SRCALPHASAT     = 11UL,		//Blend factor is (f, f, f, 1); f = min(As, 1-Ad).
+    VXBLEND_BOTHSRCALPHA    = 12UL,		//Source blend factor is (As, As, As, As) and destination blend factor is (1-As, 1-As, 1-As, 1-As)
+	VXBLEND_BOTHINVSRCALPHA = 13UL,		//Source blend factor is (1-As, 1-As, 1-As, 1-As) and destination blend factor is (As, As, As, As)
+	VXBLEND_MASK			= 0xFUL		//Source blend factor is (1-As, 1-As, 1-As, 1-As) and destination blend factor is (As, As, As, As)
+} VXBLEND_MODE;
+
+
+/******************************************************************
+{filename:VXTEXTURE_ADDRESSMODE}
+  Summary: Texture addressing modes.
+
+Remarks:
++ The VXTEXTURE_ADDRESSMODE is used by CKMaterial::SetTextureAddresMode to specify texture coordinate are 
+taken into account when they are outside the range [0.0 , 1.0].
++ Also used as value for CKRST_TSS_ADDRESS texture stage state. 
+See Also: CKMaterial,CKTexture,CKRST_TSS_ADDRESS,CKRenderContext::SetTextureStageState
+******************************************************************/
+typedef enum VXTEXTURE_ADDRESSMODE
+{
+	VXTEXTURE_ADDRESSWRAP         = 1UL,	// Default mesh wrap mode is used (see CKMesh::SetWrapMode)
+    VXTEXTURE_ADDRESSMIRROR       = 2UL,	// Texture coordinates outside the range [0..1] are flipped evenly.
+    VXTEXTURE_ADDRESSCLAMP        = 3UL,	// Texture coordinates greater than 1.0 are set to 1.0, and values less than 0.0 are set to 0.0.
+    VXTEXTURE_ADDRESSBORDER       = 4UL,	// When texture coordinates are greater than 1.0 or less than 0.0  texture is set to a color defined in CKMaterial::SetTextureBorderColor.		
+	VXTEXTURE_ADDRESSMIRRORONCE   = 5UL,	// 
+	VXTEXTURE_ADDRESSMASK         = 0x7UL	// mask for all values
+} VXTEXTURE_ADDRESSMODE;
+
+
+/******************************************************************
+{filename:VXFILL_MODE}
+  Summary:  Fill Mode Options
+  
+Remarks:
+	+ The VXFILL_MODE is used by CKMaterial::SetFillMode to specify how faces are drawn.
+	+ Also used as value for VXRENDERSTATE_FILLMODE render state. 
+See Also: CKMaterial::SetFillMode,VXRENDERSTATE_FILLMODE
+******************************************************************/
+typedef enum VXFILL_MODE
+{
+	VXFILL_POINT			= 1UL,		// Vertices rendering	
+    VXFILL_WIREFRAME		= 2UL,		// Edges rendering
+	VXFILL_SOLID			= 3UL,		// Face rendering
+	VXFILL_MASK				= 3UL
+}VXFILL_MODE; 
+
+
+/******************************************************************
+{filename:VXSHADE_MODE}
+Summary: Shade Mode Options
+
+Remarks:
+	+ The VXSHADE_MODE is used by CKMaterial::SetShadeMode to specify how color 
+	interpolation is perform on faces when they are drawn.
+	+ Also used as value for VXRENDERSTATE_SHADEMODE render state. 
+See Also: CKMaterial::SetShadeMode,VXRENDERSTATE_SHADEMODE
+******************************************************************/
+typedef enum VXSHADE_MODE
+{
+	VXSHADE_FLAT			= 1UL,	// Flat Shading
+	VXSHADE_GOURAUD			= 2UL,	// Gouraud Shading
+	VXSHADE_PHONG			= 3UL,	// Phong Shading (Not yet supported by most implementation)
+	VXSHADE_MASK			= 3UL	
+} VXSHADE_MODE; 
+
+
+/******************************************************************
+{filename:VXCMPFUNC}
+Summary:  Comparison Function
+
+Remarks:
++ Used by CKRenderContext::SetState with VXRENDERSTATE_ZFUNC, VXRENDERSTATE_ALPHAFUNC or VXRENDERSTATE_STENCILFUNC
+to specify the type of Z or Alpha comparison function. 
++ The comparison function is used to compare the stencil,alpha or z reference value to a stencil,z or alpha entry.
+See also: CKRenderContext::SetState,VXRENDERSTATETYPE,VXRENDERSTATE_ZFUNC,VXRENDERSTATE_ALPHAFUNC,
+******************************************************************/
+typedef enum VXCMPFUNC
+{
+    VXCMP_NEVER               = 1UL,	// Always fail the test.
+    VXCMP_LESS                = 2UL,	// Accept if value if less than current value.
+    VXCMP_EQUAL               = 3UL,	// Accept if value if equal than current value.
+    VXCMP_LESSEQUAL           = 4UL,	// Accept if value if less or equal than current value.
+    VXCMP_GREATER             = 5UL,	// Accept if value if greater than current value.
+    VXCMP_NOTEQUAL            = 6UL,	// Accept if value if different than current value.
+    VXCMP_GREATEREQUAL        = 7UL,	// Accept if value if greater or equal current value.
+    VXCMP_ALWAYS              = 8UL,	// Always accept the test.
+	VXCMP_MASK	              = 0xFUL	// Mask for all possible values.
+} VXCMPFUNC;
+
+/******************************************************************
+{filename:VX_EFFECT}
+Summary:  Material special effects
+
+Remarks:
++ Effects provide additionnal functionnalities to take advantage of graphic features such as bump mapping,cube maps etc... 
++ When an effect is enabled on a material (CKMaterial::SetEffect) it may override the default settings of mesh channels or material blend options
++ New effects can be created by providing a callback function (see CKRenderManager::AddEffect)
++ This enumeration provides the list of hardcoded existing effects.
++ Most of this effect are heavily hardware and device (DX8,DX7,etc..) dependant 
+See also: CKMaterial::SetEffect,CKMaterial::GetEffect,CKRenderManager::AddEffect
+******************************************************************/
+typedef enum VX_EFFECT
+{
+    VXEFFECT_NONE			= 0UL,	// No Effect
+	VXEFFECT_TEXGEN			= 1UL,	// Texture coordinate generation using current viewpoint as referential
+	VXEFFECT_TEXGENREF		= 2UL,	// texture generation generation with an optionnal referential
+	VXEFFECT_BUMPENV		= 3UL,	// Environment Bump Mapping
+	VXEFFECT_DP3			= 4UL,	// Dot Product 3 bump mapping   
+	VXEFFECT_2TEXTURES		= 5UL,	// Blend 2 Textures
+	VXEFFECT_3TEXTURES		= 6UL,	// Blend 3 Textures
+	VXEFFECT_MASK			= 0xFUL	// Mask for all possible values.
+} VX_EFFECT;
+
+
+/*****************************************************************
+{filename:VX_MOVEABLE_FLAGS}
+Summary: 3dEntity additionnal flags Options
+
+Remarks:
+	+ The VX_MOVEABLE_FLAGS is used by CK3dEntity::SetMoveableFlags to specify different hints to the render engine about the entity.
+	+ The (Engine) flags are set by the render engine and should not be modified by user. They can be checked with the CK3dEntity::GetMoveableFlags method.
+	+ The (User) flags are to be set by the user or can be set by a specific method of CK3dEntity.
+
+See Also: CK3dEntity::SetMoveableFlags
+******************************************************************/
+typedef enum VX_MOVEABLE_FLAGS { 
+		VX_MOVEABLE_PICKABLE				=0x00000001,	// (User)If not set this entity cannot be returned by CKRenderContext::Pick() or CKRenderContext::RectPict() functions.
+		VX_MOVEABLE_VISIBLE					=0x00000002,	// (Engine) See CKObject::Show,CK3dEntity::IsVisible
+		VX_MOVEABLE_UPTODATE				=0x00000004,	// (Engine) Used to Notify change in the data of the entity.
+		VX_MOVEABLE_RENDERCHANNELS			=0x00000008,	// (User) If not set, additional material channels on the mesh used by this entity won't be rendered (CK3dEntity::SetRenderChannels)	
+		VX_MOVEABLE_USERBOX					=0x00000010,	// (Engine) When CK3dEntity::SetBoundingBox is called with a user box, this flag is set.
+		VX_MOVEABLE_EXTENTSUPTODATE			=0x00000020,	// (Engine) Indicate that object 2D extents are up to date
+		VX_MOVEABLE_BOXVALID				=0x00004000,	// (Engine) If not set the moveable has no mesh associated so its bounding box is irrelevant (a point).
+		VX_MOVEABLE_RENDERLAST				=0x00010000,	// (User) If set the moveable will be rendered with the transparent objects (i.e in last) (CK3dEntity::SetRenderAsTransparent)
+		VX_MOVEABLE_HASMOVED				=0x00020000,	// (Engine) Set when its position or orientation has changed. (Reset every frame when rendering starts) 
+		VX_MOVEABLE_WORLDALIGNED			=0x00040000,	// (User) Hint for render engine : this object is aligned with world position and orientation.
+		VX_MOVEABLE_NOZBUFFERWRITE			=0x00080000,	// (User) Set by the user to warn Render Engine that this object must not write information to Z buffer
+		VX_MOVEABLE_RENDERFIRST				=0x00100000,	// (User) If set the moveable will be rendered within the firsts objects
+		VX_MOVEABLE_NOZBUFFERTEST			=0x00200000,	// (User) Set by the user to warn Render Engine that this object must not test against Z buffer (This override settings of all materials used by this Entity)
+		VX_MOVEABLE_INVERSEWORLDMATVALID	=0x00400000,	// (Engine) Inverse world matrix is not up to date and should be recomputed
+		VX_MOVEABLE_DONTUPDATEFROMPARENT	=0x00800000,	// (User) This object will not be updated by parent (neither World nor Local matrix wil be updated) . This flags can be used by physic engine for example in which hierarchy is not relevant for physicalised objects
+		VX_MOVEABLE_INDIRECTMATRIX			=0x01000000,	// (User/Engine) Set by the engine at load time  : The object matrix is in left hand referential, culling needs to be inverted
+		VX_MOVEABLE_ZBUFONLY				=0x02000000,	// (User) The object will only be rendered in depth buffer
+		VX_MOVEABLE_STENCILONLY				=0x04000000,	// (User) The object will only be rendered in stencil buffer
+		VX_MOVEABLE_HIERARCHICALHIDE		=0x10000000,	// (Engine) If Object has this flags and is hidden its children won't be rendered
+		VX_MOVEABLE_CHARACTERRENDERED		=0x20000000,	// (Engine) Set if a character was rendered last frame...
+		VX_MOVEABLE_RESERVED2				=0x40000000,	// (Engine)
+} VX_MOVEABLE_FLAGS;
+
+
+/*****************************************************************
+{filename:VXMESH_FLAGS}
+Summary:Mesh Flags Options
+
+Remarks:
+	+ The VXMESH_FLAGS is used by CKMesh::SetFlags to specify different hints to the render engine about the mesh.
+	+ Most of this flags can be set or asked using the appropriate method of CKMesh (given between () in the members documentation).
+See Also: CKMesh,CKMesh::SetFlags
+******************************************************************/
+typedef enum VXMESH_FLAGS
+{
+		VXMESH_BOUNDINGUPTODATE		= 0x00000001,	//	If set the bounding box is up to date (internal).
+		VXMESH_VISIBLE				= 0x00000002,	//	If not set the mesh will not be rendered (CKMesh::Show)
+		VXMESH_OPTIMIZED			= 0x00000004,	//	Set by the render engine if the mesh is optimized for rendering. Unset it to force to recreate optimized structures (when changing materials or face organization ) (CKMesh::VertexMove)
+		VXMESH_RENDERCHANNELS		= 0x00000008,	//  If not set  Additional material channels won't be rendered.
+		VXMESH_HASTRANSPARENCY		= 0x00000010,	//	If set indicates that one or more of the faces of this mesh use a transparent material (internal)
+		VXMESH_PRELITMODE			= 0x00000080,	//	If set, no lightning should occur for this mesh, vertex color should be used instead (CKMesh::SetLitMode)
+		VXMESH_WRAPU				= 0x00000100,	//	Texture coordinates wrapping among u texture coordinates. (CKMesh::SetWrapMode) 
+		VXMESH_WRAPV				= 0x00000200,	//	Texture coordinates wrapping among v texture coordinates. (CKMesh::SetWrapMode)
+		VXMESH_FORCETRANSPARENCY	= 0x00001000,	//	Forces this mesh to be considered as transparent even if no material is tranparent. (CKMesh::SetTransparent)
+		VXMESH_TRANSPARENCYUPTODATE	= 0x00002000,	//	If set, the flags VXMESH_HASTRANSPARENCY is up to date. (internal) 
+		VXMESH_UV_CHANGED			= 0x00004000,	//	Must be set if texture coordinates changed to enable the render engine to reconstruct potential display lists or vertex buffers. (CKMesh::UVChanged)
+		VXMESH_NORMAL_CHANGED		= 0x00008000,	//	Must be set if normal coordinates changed to enable the render engine to reconstruct potential display lists or vertex buffers. (CKMesh::NormalChanged)
+		VXMESH_COLOR_CHANGED		= 0x00010000,	//	Must be set if colors changed to enable the render engine to reconstruct potential display lists or vertex buffers.	(CKMesh::ColorChanged)
+		VXMESH_POS_CHANGED			= 0x00020000,	//	Must be set if vertex position changed to enable the render engine to reconstruct potential display lists or vertex buffers. (CKMesh::VertexMove)
+		VXMESH_HINTDYNAMIC			= 0x00040000,	//  Hint for render engine : Mesh geometry is updated frequently
+		VXMESH_GENNORMALS			= 0x00080000,	//  Hint : Normals were generated by BuildNormals : Do not save	(internal)
+		VXMESH_PROCEDURALUV			= 0x00100000,	//  Hint : UVs are generated : Do not save (internal)
+		VXMESH_PROCEDURALPOS		= 0x00200000,	//  Hint : Vertices postions are generated : Do not save (internal)
+		VXMESH_STRIPIFY				= 0x00400000,	//  If set the mesh will be stripified.
+		VXMESH_MONOMATERIAL			= 0x00800000,	//  Set by the render engine if the mesh use only one material.
+		VXMESH_PM_BUILDNORM			= 0x01000000,	//  Build normals when performing progressive meshing : Do not save (internal)
+		VXMESH_BWEIGHTS_CHANGED		= 0x02000000,	//	Must be set if vertex blend weights have changed to enable the render engine to reconstruct potential display lists or vertex buffers. (CKMesh::VertexMove)
+		VXMESH_ALLFLAGS				= 0x007FF39F
+} VXMESH_FLAGS;
+
+
+/******************************************************************
+{filename:VXMESH_LITMODE}
+Summary: Mesh lighting options
+
+Remarks:
+  + The VXMESH_LITMODE is used by CKMesh::SetLitMode to specify how lighting is done.
+See Also: CKMaterial,CKMesh
+******************************************************************/
+typedef enum VXMESH_LITMODE
+{
+	 VX_PRELITMESH = 0,		// Lighting use color information store with vertices
+	 VX_LITMESH	   = 1,		// Lighting is done by renderer using normals and face material information. 
+} VXMESH_LITMODE;
+
+/*****************************************************************
+{filename:VXCHANNEL_FLAGS}
+Summary:Mesh additionnal material channel options
+
+Remarks:
+	+ The VXCHANNEL_FLAGS is used by CKMesh::SetChannelFlags to give the behavior of 
+	an additional material channel.
+See Also: CKMesh,CKMesh::AddChannel,CKMesh::IsChannelLit,CKMesh::IsChannelActive
+******************************************************************/
+typedef enum VXCHANNEL_FLAGS {
+	VXCHANNEL_ACTIVE	=	0x00000001,		// This channel is active
+	VXCHANNEL_SAMEUV	=	0x00800000,		// This channel should use the texture coordinates of the base mesh.
+	VXCHANNEL_NOTLIT	=	0x01000000,		// Additionnal Material Channel should not be lit (some channels may not be rendered in one pass with this option)
+	VXCHANNEL_MONO		=	0x02000000,		// Set at runtime by render engine to indicate whether this channel was rendered using multiple pass or not.(Dot Not Modify)
+	VXCHANNEL_RESERVED1  =	0x04000000,		// Reserved for internal use
+	VXCHANNEL_LAST		=	0x08000000,		// Set at runtime by render engine to indicate this channel isthe last to be rendered. Dot Not Modify 
+} VXCHANNEL_FLAGS;
+
+/****************************************************************
+{filename:VXTEXTURE_WRAPMODE}
+Summary: Wrapping Flags
+
+Remarks:
+	+ The VXTEXTURE_WRAPMODE is used by CKMesh::SetWrapMode() to specify how
+	texture coordinates are interpolated.
+See Also: Using Materials,CKMaterial,CKMesh::SetWrapMode.
+****************************************************************/
+typedef enum VXTEXTURE_WRAPMODE
+{
+	VXTEXTUREWRAP_NONE = 0x00000000,	// Flat texture addressing
+	VXTEXTUREWRAP_U	   = 0x00000001,	// Vertical	cylinder mapping
+	VXTEXTUREWRAP_V	   = 0x00000002,	// Horizontal cylinder mapping
+	VXTEXTUREWRAP_UV   = 0x00000003,	// Spherical mapping
+} VXTEXTURE_WRAPMODE;
+
+

Assets/CodeGen/VectorGen/.gitignore

@@ -0,0 +1,3 @@
+# Result
+VxTypes.hpp
+VxTypes.cpp

Assets/CodeGen/VectorGen/README.md

@@ -0,0 +1,3 @@
+# Vector Generator
+
+Vector types (LibCmo::VxMath::VxVector3 and etc) and Vector-like types (LibCmo::VxMath::VxColor and etc) nearly have similar declaration except slight differences (basically is the count of factors). Manually writing these declarations is boring and easy to cause potential invisible bugs. So we use a Python script to generate these declarations batchly to prevent any defects indroduced above.

Assets/CodeGen/VectorGen/VxTypes.cpp.jinja

@@ -0,0 +1,178 @@
+{% import 'VxTypes.shared.jinja' as shared %}
+{#
+For friend operator overload, we do not need add CLASSNAME:: prefix for it.
+Because they are not a part of that class.
+#}
+
+#pragma region {{ sname }}
+
+{# Ctor type 1 - Default ctor -#}
+{{ sname }}::{{ sname }}() : {{- shared.initialize_list_builder(svars, False) -}} {} {% if not is_vector %}// SET YOUR CUSTOM INIT{% endif %}
+{#- Ctor type 2 - User specified ctor #}
+{{ sname }}::{{ sname }}({{- shared.argument_list_builder(svars) -}}) : {{- shared.initialize_list_builder(svars, True) -}} {}
+
+{#- Offset operator #}
+CKFLOAT& {{ sname }}::operator[](size_t i) {
+    switch (i) {
+        {%- for item in svars %}
+        case {{ loop.index0 }}: return {{ item }};
+        {%- endfor %}
+        default: throw LogicException("Invalid index for {{ sname }}::operator[].");
+    }
+}
+const CKFLOAT& {{ sname }}::operator[](size_t i) const {
+    switch (i) {
+        {%- for item in svars %}
+        case {{ loop.index0 }}: return {{ item }};
+        {%- endfor %}
+        default: throw LogicException("Invalid index for {{ sname }}::operator[].");
+    }
+}
+
+{#- Equal operator #}
+bool {{ sname }}::operator==(const {{ sname }}& rhs) const {
+    return (
+        {%- for item in svars -%}
+        {{ item }} == rhs.{{ item }} {%- if not loop.last %} && {% endif %}
+        {%- endfor -%}
+    );
+}
+
+{#- Spaceship operator #}
+auto {{ sname }}::operator<=>(const {{ sname }}& rhs) const {
+    {%- for item in svars[:-1] %}
+    if (auto cmp = {{ item }} <=> rhs.{{ item }}; cmp != 0) return cmp;
+    {%- endfor %}
+    return {{ svars[-1] }} <=> rhs.{{ svars[-1] }};
+}
+
+
+{#- BEGIN VECTOR SPECIFIC #}
+{%- if is_vector %}
+
+{#- Add, minus operators #}
+{#- Unary operators #}
+{{ sname }} {{ sname }}::operator+() const {
+    return *this;
+}
+{{ sname }} {{ sname }}::operator-() const {
+    return {{ sname }}(
+        {%- for item in svars -%}
+        -{{ item }} {%- if not loop.last %}, {% endif %}
+        {%- endfor -%}
+    );
+}
+{#- Additive operators #}
+{{ sname }}& {{ sname }}::operator+=(const {{ sname }}& rhs) {
+    {%- for item in svars %}
+    {{ item }} += rhs.{{ item }};
+    {%- endfor %}
+    return *this;
+}
+{{ sname }} operator+(const {{ sname }}& lhs, const {{ sname }}& rhs) {
+    return {{ sname }}(
+        {%- for item in svars -%}
+        lhs.{{ item }} + rhs.{{ item }} {%- if not loop.last %}, {% endif %}
+        {%- endfor -%}
+    );
+}
+{{ sname }}& {{ sname }}::operator-=(const {{ sname }}& rhs) {
+    {%- for item in svars %}
+    {{ item }} -= rhs.{{ item }};
+    {%- endfor %}
+    return *this;
+}
+{{ sname }} operator-(const {{ sname }}& lhs, const {{ sname }}& rhs) {
+    return {{ sname }}(
+        {%- for item in svars -%}
+        lhs.{{ item }} - rhs.{{ item }} {%- if not loop.last %}, {% endif %}
+        {%- endfor -%}
+    );
+}
+
+{#- Mul operator #}
+{{ sname }}& {{ sname }}::operator*=(CKFLOAT rhs) {
+    {%- for item in svars %}
+    {{ item }} *= rhs;
+    {%- endfor %}
+    return *this;
+}
+{{ sname }} operator*(const {{ sname }}& lhs, CKFLOAT rhs) {
+    return {{ sname }}(
+        {%- for item in svars -%}
+        lhs.{{ item }} * rhs {%- if not loop.last %}, {% endif %}
+        {%- endfor -%}
+    );
+}
+{{ sname }} operator*(CKFLOAT lhs, const {{ sname }}& rhs) {
+    return {{ sname }}(
+        {%- for item in svars -%}
+        lhs * rhs.{{ item }} {%- if not loop.last %}, {% endif %}
+        {%- endfor -%}
+    );
+}
+CKFLOAT operator*(const {{ sname }}& lhs, const {{ sname }}& rhs) {
+    return (
+        {%- for item in svars -%}
+        lhs.{{ item }} * rhs.{{ item }} {%- if not loop.last %} + {% endif %}
+        {%- endfor -%}
+    );
+}
+
+{#- Div operator #}
+{{ sname }}& {{ sname }}::operator/=(CKFLOAT rhs) {
+    if (rhs == 0.0f) return *this;
+    {%- for item in svars %}
+    {{ item }} /= rhs;
+    {%- endfor %}
+    return *this;
+}
+{{ sname }} operator/(const {{ sname }}& lhs, CKFLOAT rhs) {
+    if (rhs == 0.0f) return {{ sname }}();
+    else return {{ sname }}(
+            {%- for item in svars -%}
+            lhs.{{ item }} / rhs {%- if not loop.last %}, {% endif %}
+            {%- endfor -%}
+        );
+}
+
+{#- Length functions #}
+CKFLOAT {{ sname }}::SquaredLength() const {
+    return (
+        {%- for item in svars -%}
+        {{ item }} * {{ item }} {%- if not loop.last %} + {% endif %}
+        {%- endfor -%}
+    );
+}
+CKFLOAT {{ sname }}::Length() const {
+    return std::sqrt(SquaredLength());
+}
+
+{#- Normalize functions #}
+void {{ sname }}::Normalized() {
+    CKFLOAT len = Length();
+    if (len == 0.0f) return;
+    {%- for item in svars %}
+    {{ item }} /= len;
+    {%- endfor %}
+}
+{{ sname }} {{ sname }}::Normalize() const {
+    CKFLOAT len = Length();
+    if (len == 0.0f) return {{ sname }}();
+    else return {{ sname }}(
+        {%- for item in svars -%}
+        {{ item }} / len {%- if not loop.last %}, {% endif %}
+        {%- endfor -%}
+    );
+}
+
+{%- endif %}
+{#- END VECTOR SPECIFIC #}
+
+
+{#- User custom region #}
+
+/* ===== BEGIN USER CUSTOM ===== */
+/* =====  END  USER CUSTOM ===== */
+
+#pragma endregion

Assets/CodeGen/VectorGen/VxTypes.hpp.jinja

@@ -0,0 +1,65 @@
+{% import 'VxTypes.shared.jinja' as shared %}
+
+struct {{ sname }} {
+    {#- Variable declaration #}
+	CKFLOAT {{ ", ".join(svars) }};
+
+    {#- Ctor type 1 - Default ctor #}
+	{{ sname }}();
+    {#- Ctor type 2 - User specified ctor #}
+	{{ sname }}({{- shared.argument_list_builder(svars) -}});
+
+    {#- Default copy ctor, move ctor, copy assigner, move assigner #}
+	YYCC_DEF_CLS_COPY_MOVE({{ sname }});
+    
+    {#- Offset operator #}
+	CKFLOAT& operator[](size_t i);
+	const CKFLOAT& operator[](size_t i) const;
+
+    {#- Equal operator #}
+	bool operator==(const {{ sname }}& rhs) const;
+
+    {#- Spaceship operator #}
+	auto operator<=>(const {{ sname }}& rhs) const;
+
+
+	{#- BEGIN VECTOR SPECIFIC #}
+	{%- if is_vector %}
+
+    {#- Add, minus operators #}
+    {#- Unary operators #}
+    {{ sname }} operator+() const;
+    {{ sname }} operator-() const;
+    {#- Additive operators #}
+	{{ sname }}& operator+=(const {{ sname }}& rhs);
+	friend {{ sname }} operator+(const {{ sname }}& lhs, const {{ sname }}& rhs);
+	{{ sname }}& operator-=(const {{ sname }}& rhs);
+	friend {{ sname }} operator-(const {{ sname }}& lhs, const {{ sname }}& rhs);
+
+    {#- Mul operator #}
+	{{ sname }}& operator*=(CKFLOAT rhs);
+	friend {{ sname }} operator*(const {{ sname }}& lhs, CKFLOAT rhs);
+	friend {{ sname }} operator*(CKFLOAT lhs, const {{ sname }}& rhs);
+	friend CKFLOAT operator*(const {{ sname }}& lhs, const {{ sname }}& rhs);
+
+    {#- Div operator #}
+	{{ sname }}& operator/=(CKFLOAT rhs);
+	friend {{ sname }} operator/(const {{ sname }}& lhs, CKFLOAT rhs);
+	
+    {#- Length functions #}
+	CKFLOAT SquaredLength() const;
+	CKFLOAT Length() const;
+
+    {#- Normalize functions #}
+	void Normalized();
+	{{ sname }} Normalize() const;
+
+	{%- endif %}
+	{#- END VECTOR SPECIFIC #}
+
+
+	{#- User custom region #}
+
+	/* ===== BEGIN USER CUSTOM ===== */
+	/* =====  END  USER CUSTOM ===== */
+};

Assets/CodeGen/VectorGen/VxTypes.shared.jinja

@@ -0,0 +1,21 @@
+{#
+The macro to generate C++ ctor argument list
+It produce like this: `CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w`
+#}
+{% macro argument_list_builder(svars) %}
+{%- for item in svars -%}
+CKFLOAT _{{- item -}}{%- if not loop.last %}, {% endif -%}
+{%- endfor -%}
+{% endmacro %}
+
+{#
+The macro to generate C++ ctor initialize list
+It produce like this: `x(0.0f), y(0.0f), z(0.0f), w(0.0f)`
+or this: `x(_x), y(_y), z(_z), w(_w)`
+according to user request.
+#}
+{% macro initialize_list_builder(svars, is_user) %}
+{%- for item in svars -%}
+{{- item -}}({%- if is_user -%}_{{- item -}}{%- else -%}0.0f{%- endif -%}){%- if not loop.last %}, {% endif -%}
+{%- endfor -%}
+{% endmacro %}

Assets/CodeGen/VectorGen/VxVectorGen.py

@@ -0,0 +1,63 @@
+import os
+import io
+import typing
+import jinja2
+
+g_HppTemplateFile: str = 'VxTypes.hpp.jinja'
+g_CppTemplateFile: str = 'VxTypes.cpp.jinja'
+
+g_ResultHppFile: str = 'VxTypes.hpp'
+g_ResultCppFile: str = 'VxTypes.cpp'
+
+def get_root_directory() -> str:
+    return os.path.dirname(__file__)
+
+class TemplateRender:
+    m_Loader: jinja2.BaseLoader
+    m_Environment: jinja2.Environment
+
+    m_HppTemplate: jinja2.Template
+    m_CppTemplate: jinja2.Template
+
+    m_OutputHpp: io.TextIOWrapper
+    m_OutputCpp: io.TextIOWrapper
+
+    def __init__(self, output_hpp_path: str, output_cpp_path: str) -> None:
+        self.m_Loader = jinja2.FileSystemLoader(get_root_directory())
+        self.m_Environment = jinja2.Environment(loader=self.m_Loader)
+
+        self.m_HppTemplate = self.m_Environment.get_template(g_HppTemplateFile)
+        self.m_CppTemplate = self.m_Environment.get_template(g_CppTemplateFile)
+
+        self.m_OutputHpp = open(os.path.join(get_root_directory(), output_hpp_path), 'w', encoding='utf-8')
+        self.m_OutputCpp = open(os.path.join(get_root_directory(), output_cpp_path), 'w', encoding='utf-8')
+
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.m_OutputHpp.close()
+        self.m_OutputCpp.close()
+    
+    def __render(self, sname: str, is_vector: bool, svars: tuple[str]) -> None:
+        template_argument: dict[str, typing.Any] = {
+            'sname': sname,
+            'is_vector': is_vector,
+            'svars': svars
+        }
+        self.m_OutputHpp.write(self.m_HppTemplate.render(**template_argument))
+        self.m_OutputCpp.write(self.m_CppTemplate.render(**template_argument))
+
+    def render_vector(self, sname: str, svars: tuple[str]) -> None:
+        self.__render(sname, True, svars)
+
+    def render_others(self, sname: str, svars: tuple[str]) -> None:
+        self.__render(sname, False, svars)
+
+if __name__ == '__main__':
+    with TemplateRender(g_ResultHppFile, g_ResultCppFile) as render:
+        render.render_vector('VxVector2', ('x', 'y', ))
+        render.render_vector('VxVector3', ('x', 'y', 'z', ))
+        render.render_vector('VxVector4', ('x', 'y', 'z', 'w', ))
+        render.render_others('VxQuaternion', ('x', 'y', 'z', 'w', ))
+        render.render_others('VxColor', ('r', 'g', 'b', 'a', ))