write some boring struct in VxTypes

CodeGen/EnumsMigration/.gitignore

@@ -0,0 +1,38 @@
+# Antlr output
+*.interp
+*.tokens
+
+CKGeneralLexer*.java
+CKEnumsParser*.java
+CKDefinesParser*.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*

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) ;

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
+;

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);

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;
+	}
+
+}

CodeGen/EnumsMigration/ClassidWriter.java

@@ -0,0 +1,24 @@
+import java.io.OutputStreamWriter;
+import java.util.stream.Collectors;
+
+/**
+ * The nameof values writer for CK_CLASSID.
+ */
+public class ClassidWriter {
+	public static void writeAccVals(OutputStreamWriter writer, EnumsHelper.Enum_t classids) throws Exception {
+		IndentHelper indent = new IndentHelper(writer);
+
+		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("\", \""));
+			indent.printf("{ LibCmo::CK2::CK_CLASSID::%s, { { \"%s\" } } },", entry.mEntryName, hierarchy);
+		}
+		indent.dec();
+		indent.puts("};");
+
+	}
+}

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;
+		}
+	}
+
+}

CodeGen/EnumsMigration/CommonHelper.java

@@ -0,0 +1,181 @@
+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 comment.getText().substring(2);
+		}
+		case CKGeneralLexer.CKGENERAL_BLOCK_COMMENT: {
+			String cache = comment.getText();
+			return 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");
+	}
+	
+	/**
+	 * Get underlying type of enum.
+	 * 
+	 * @param canUnsigned The parameter stored in Enum_t that indiccate whether this
+	 *                    enum can use unsigned int as its underlying type.
+	 * @return The string form of its underlying type.
+	 */
+	public static String getEnumUnderlyingType(boolean canUnsigned) {
+		return canUnsigned ? "uint32_t" : "int32_t";
+	}
+
+	// =========== Parts ===========
+
+	enum CKParts {
+		CK2, VxMath
+	}
+
+	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", "");
+	}
+
+}

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;
+	}
+	
+}

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.
+	}
+
+}

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;
+
+	}
+
+}

CodeGen/EnumsMigration/ErrorsWriter.java

@@ -0,0 +1,24 @@
+import java.io.OutputStreamWriter;
+
+/**
+ * The nameof values writer for CKERROR
+ */
+public class ErrorsWriter {
+	public static void writeAccVals(OutputStreamWriter writer, EnumsHelper.Enum_t errors) throws Exception {
+		IndentHelper indent = new IndentHelper(writer);
+
+		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, { \"%s\", \"%s\" } },", entry.mEntryName, entry.mEntryName,
+					comment);
+		}
+		indent.dec();
+		indent.puts("};");
+
+	}
+}

CodeGen/EnumsMigration/GeneralWriter.java

@@ -0,0 +1,83 @@
+import java.io.OutputStreamWriter;
+
+/**
+ * Generic Enum Writer. Including Data Type Defination and Nameof Values.
+ */
+public class GeneralWriter {
+
+	public static void writeEnums(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog) throws Exception {
+		IndentHelper indent = new IndentHelper(writer);
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			// write enum comment
+			indent.briefComment(enum_t.mEnumComment);
+
+			// write enum start
+			indent.printf("enum class %s : %s {", enum_t.mEnumName,
+					CommonHelper.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("};");
+		}
+	}
+
+	public static void writeEnum(OutputStreamWriter writer, EnumsHelper.Enum_t _enum) throws Exception {
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		writeEnums(writer, col);
+	}
+
+	public static void writeAccVals(OutputStreamWriter writer, EnumsHelper.EnumCollection_t prog,
+			CommonHelper.CKParts parts) throws Exception {
+		IndentHelper indent = new IndentHelper(writer);
+		// write decls
+		for (EnumsHelper.Enum_t enum_t : prog.mEnums) {
+			indent.printf("extern const GeneralReflectionArray<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, {\"%s\"} },", CommonHelper.getCKPartsNamespace(parts),
+						enum_t.mEnumName, enumEntry_t.mEntryName, enumEntry_t.mEntryName);
+			}
+
+			// write enum tail
+			indent.dec();
+			indent.puts("};");
+		}
+	}
+
+	public static void writeAccVal(OutputStreamWriter writer, EnumsHelper.Enum_t _enum, CommonHelper.CKParts parts)
+			throws Exception {
+		EnumsHelper.EnumCollection_t col = new EnumsHelper.EnumCollection_t();
+		col.mEnums.add(_enum);
+		writeAccVals(writer, col, parts);
+	}
+
+}

CodeGen/EnumsMigration/IndentHelper.java

@@ -0,0 +1,65 @@
+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;
+	}
+
+	public void indent() throws Exception {
+		mWriter.write("\n");
+		for (int i = 0; i < mIndent; ++i) {
+			mWriter.write("\t");
+		}
+	}
+
+	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;
+		puts("/**");
+		puts(comment);
+		puts(" */");
+	}
+
+	/**
+	 * 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(String.format("\t/**< %s */", CommonHelper.removeEol(comment)));
+	}
+
+}

CodeGen/EnumsMigration/MainRunner.java

@@ -0,0 +1,133 @@
+import java.io.OutputStreamWriter;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.*;
+
+public class MainRunner {
+
+	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();
+	}
+
+	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;
+	}
+
+	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 {
+		OutputStreamWriter fs = null;
+		
+		// =========== CKERROR ===========
+		EnumsHelper.Enum_t ckerror = organiseDefines("src/CKError.txt", "CKERROR");
+		fs = CommonHelper.openOutputFile("dest/CKError.hpp");
+		GeneralWriter.writeEnum(fs, ckerror);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/CKError.AccVal.hpp");
+		ErrorsWriter.writeAccVals(fs, ckerror);
+		fs.close();
+		
+		// =========== CK_CLASSID ===========
+		EnumsHelper.Enum_t classid = organiseClassid("src/CK_CLASSID.txt");
+		fs = CommonHelper.openOutputFile("dest/CK_CLASSID.hpp");
+		GeneralWriter.writeEnum(fs, classid);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/CK_CLASSID.AccVal.hpp");
+		ClassidWriter.writeAccVals(fs, classid);
+		fs.close();
+		
+		// =========== Define2 ===========
+		// Define2 do not need values.
+		EnumsHelper.EnumCollection_t def2 = getEnumsCollection("src/Defines2.txt");
+		fs = CommonHelper.openOutputFile("dest/CK_CLASSID.hpp");
+		GeneralWriter.writeEnums(fs, def2);
+		fs.close();
+		
+		// =========== Combined enums ===========
+		EnumsHelper.EnumCollection_t ck2Enums = getEnumsCollection("src/CKEnums.txt"),
+				vxEnums = getEnumsCollection("src/VxEnums.txt");
+		fs = CommonHelper.openOutputFile("dest/CKEnums.hpp");
+		GeneralWriter.writeEnums(fs, ck2Enums);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/CKEnums.AccVal.hpp");
+		GeneralWriter.writeAccVals(fs, ck2Enums, CommonHelper.CKParts.CK2);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/VxEnums.hpp");
+		GeneralWriter.writeEnums(fs, vxEnums);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/VxEnums.AccVal.hpp");
+		GeneralWriter.writeAccVals(fs, vxEnums, CommonHelper.CKParts.VxMath);
+		fs.close();
+		
+		// =========== Single enums ===========
+		EnumsHelper.Enum_t single;
+		
+		single = organiseDefines("src/CK_STATECHUNK_CHUNKVERSION.txt", "CK_STATECHUNK_CHUNKVERSION");
+		fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_CHUNKVERSION.hpp");
+		GeneralWriter.writeEnum(fs, single);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_CHUNKVERSION.AccVal.hpp");
+		GeneralWriter.writeAccVal(fs, single, CommonHelper.CKParts.CK2);
+		fs.close();
+
+		single = organiseDefines("src/CK_STATECHUNK_DATAVERSION.txt", "CK_STATECHUNK_DATAVERSION");
+		fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_DATAVERSION.hpp");
+		GeneralWriter.writeEnum(fs, single);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/CK_STATECHUNK_DATAVERSION.AccVal.hpp");
+		GeneralWriter.writeAccVal(fs, single, CommonHelper.CKParts.CK2);
+		fs.close();
+		
+		single = organiseDefines("src/CK_BITMAPDATA_FLAGS.txt", "CK_BITMAPDATA_FLAGS");
+		fs = CommonHelper.openOutputFile("dest/CK_BITMAPDATA_FLAGS.hpp");
+		GeneralWriter.writeEnum(fs, single);
+		fs.close();
+		fs = CommonHelper.openOutputFile("dest/CK_BITMAPDATA_FLAGS.AccVal.hpp");
+		GeneralWriter.writeAccVal(fs, single, CommonHelper.CKParts.CK2);
+		fs.close();
+		
+		// print message.
+		System.out.println("DONE!");
+	}
+}

CodeGen/EnumsMigration/README.md

@@ -0,0 +1,12 @@
+# Code Gen
+
+A helper program to generate some definations.
+
+```
+antlr4 CKGeneralLexer.g4
+antlr4 CKEnumsParser.g4
+antlr4 CKDefinesParser.g4
+
+javac *.java
+java MainRunner
+```

CodeGen/EnumsMigration/src/CKEnums.txt

@@ -0,0 +1,330 @@
+/*************************************************
+{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...
+};
+
+/***************************************************
+{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: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: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;

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

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		

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

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 

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	

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;

CodeGen/EnumsMigration/src/VxEnums.txt

@@ -0,0 +1,43 @@
+
+/*****************************************************************
+{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;
+