Renamed C# serialization classes so they start with word Managed instead of Script (need the Script names for actual ScriptObjects)

MBansheeEditor/Inspector/SerializableObject.cs

@@ -1,23 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BansheeEditor
-{
-    public sealed class SerializableObject
-    {
-        private SerializableField[] _fields;
-
-        public SerializableObject(object obj)
-        {
-            // TODO - Populate _fields
-        }
-
-        public SerializableField[] fields
-        {
-            get { return _fields; }
-        }
-    }
-}

MBansheeEditor/MBansheeEditor.csproj

@@ -45,13 +45,9 @@
     <Compile Include="EditorWindow.cs" />
     <Compile Include="Inspector\CustomInspector.cs" />
     <Compile Include="Inspector\GenericInspector.cs" />
-    <Compile Include="Inspector\SerializableArray.cs" />
-    <Compile Include="Inspector\SerializableField.cs" />
     <Compile Include="Inspector\InspectableObject.cs" />
     <Compile Include="Inspector\Inspector.cs" />
     <Compile Include="Inspector\InspectorWindow.cs" />
-    <Compile Include="Inspector\SerializableObject.cs" />
-    <Compile Include="Inspector\SerializableValue.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

MBansheeEngine/DbgSerzCls.cs

@@ -5,7 +5,7 @@ using System.Text;
 
 namespace BansheeEngine
 {
-    [SerializableObject]
+    [SerializeObject]
     public class DbgSerzCls
     {
         public int someValue2;

MBansheeEngine/DbgSerzObj.cs

@@ -5,7 +5,7 @@ using System.Text;
 
 namespace BansheeEngine
 {
-    [SerializableObject]
+    [SerializeObject]
     public struct DbgSerzObj
     {
         public DbgSerzObj(int someValue, string anotherValue)

MBansheeEngine/MBansheeEngine.csproj

@@ -84,7 +84,11 @@
     <Compile Include="Resource.cs" />
     <Compile Include="SceneObject.cs" />
     <Compile Include="ScriptObject.cs" />
+    <Compile Include="SerializableArray.cs" />
+    <Compile Include="SerializableField.cs" />
     <Compile Include="SerializableObject.cs" />
+    <Compile Include="SerializableValue.cs" />
+    <Compile Include="SerializeObject.cs" />
     <Compile Include="SerializeField.cs" />
     <Compile Include="SpriteTexture.cs" />
     <Compile Include="StringTable.cs" />

MBansheeEditor/Inspector/SerializableArray.cs → MBansheeEngine/SerializableArray.cs

@@ -5,7 +5,7 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
     public sealed class SerializableArray
     {

MBansheeEditor/Inspector/SerializableField.cs → MBansheeEngine/SerializableField.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
     public class SerializableField
     {

MBansheeEngine/SerializableObject.cs

@@ -1,9 +1,23 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
 
 namespace BansheeEngine
 {
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
-    public sealed class SerializableObject : Attribute
+    public sealed class SerializableObject
     {
+        private SerializableField[] _fields;
+
+        public SerializableObject(object obj)
+        {
+            // TODO - Populate _fields
+        }
+
+        public SerializableField[] fields
+        {
+            get { return _fields; }
+        }
     }
 }

MBansheeEditor/Inspector/SerializableValue.cs → MBansheeEngine/SerializableValue.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
     public sealed class SerializableValue
     {

MBansheeEngine/SerializeObject.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace BansheeEngine
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
+    public sealed class SerializeObject : Attribute
+    {
+    }
+}

SBansheeEngine/Include/BsManagedComponentRTTI.h

@@ -5,7 +5,7 @@
 #include "CmGameObjectRTTI.h"
 #include "BsManagedComponent.h"
 #include "BsMonoManager.h"
-#include "BsScriptSerializableObject.h"
+#include "BsManagedSerializableObject.h"
 #include "CmGameObjectManager.h"
 
 namespace BansheeEngine
@@ -33,12 +33,12 @@ namespace BansheeEngine
 			obj->mTypeName = val;
 		}
 
-		ScriptSerializableObjectPtr getObjectData(ManagedComponent* obj)
+		ManagedSerializableObjectPtr getObjectData(ManagedComponent* obj)
 		{
-			return boost::any_cast<ScriptSerializableObjectPtr>(obj->mRTTIData);
+			return boost::any_cast<ManagedSerializableObjectPtr>(obj->mRTTIData);
 		}
 
-		void setObjectData(ManagedComponent* obj, ScriptSerializableObjectPtr val)
+		void setObjectData(ManagedComponent* obj, ManagedSerializableObjectPtr val)
 		{
 			obj->mRTTIData = val;
 		}
@@ -55,7 +55,7 @@ namespace BansheeEngine
 		{
 			ManagedComponent* mc = static_cast<ManagedComponent*>(obj);
 
-			mc->mRTTIData = ScriptSerializableObject::create(mc->getManagedInstance());
+			mc->mRTTIData = ManagedSerializableObject::create(mc->getManagedInstance());
 		}
 
 		virtual void onDeserializationStarted(IReflectable* obj)
@@ -67,7 +67,7 @@ namespace BansheeEngine
 
 		static void finalizeDeserialization(ManagedComponent* mc)
 		{
-			ScriptSerializableObjectPtr serializableObject = boost::any_cast<ScriptSerializableObjectPtr>(mc->mRTTIData);
+			ManagedSerializableObjectPtr serializableObject = boost::any_cast<ManagedSerializableObjectPtr>(mc->mRTTIData);
 
 			::MonoClass* monoClass = mono_object_get_class(serializableObject->getManagedInstance());
 			MonoType* monoType = mono_class_get_type(monoClass);

SBansheeEngine/Include/BsScriptSerializableArray.h → SBansheeEngine/Include/BsManagedSerializableArray.h

@@ -1,63 +1,63 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmIReflectable.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableArray : public IReflectable
-	{
-	private:
-		struct ConstructPrivately {};
-
-	public:
-		ScriptSerializableArray(const ConstructPrivately& dummy, const ScriptSerializableTypeInfoArrayPtr& typeInfo, MonoObject* managedInstance);
-		ScriptSerializableArray(const ConstructPrivately& dummy);
-
-		MonoObject* getManagedInstance() const { return mManagedInstance; }
-
-		static ScriptSerializableArrayPtr create(MonoObject* managedInstance, const ScriptSerializableTypeInfoArrayPtr& typeInfo);
-
-	protected:
-		MonoObject* mManagedInstance;
-		::MonoClass* mElementMonoClass;
-
-		ScriptSerializableTypeInfoArrayPtr mArrayTypeInfo;
-		Vector<ScriptSerializableFieldDataPtr>::type mArrayEntries;
-		
-		Vector<UINT32>::type mNumElements;
-		UINT32 mElemSize;
-
-		void initMonoObjects();
-
-		/**
-		 * @brief	Populates internal field data based on currently active managed instance.
-		 */
-		void serializeManagedInstance();
-
-		/**
-		 * @brief	Creates a new managed instance and populates it with stored field data.
-		 */
-		void deserializeManagedInstance();
-
-		void setFieldData(UINT32 arrayIdx, const ScriptSerializableFieldDataPtr& val);
-		ScriptSerializableFieldDataPtr getFieldData(UINT32 arrayIdx);
-
-		void setValue(UINT32 arrayIdx, void* val);
-
-		UINT32 toSequentialIdx(const Vector<UINT32>::type& idx) const;
-		UINT32 getLength(UINT32 dimension) const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-		
-		static ScriptSerializableArrayPtr createEmpty();
-
-	public:
-		friend class ScriptSerializableArrayRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmIReflectable.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableArray : public IReflectable
+	{
+	private:
+		struct ConstructPrivately {};
+
+	public:
+		ManagedSerializableArray(const ConstructPrivately& dummy, const ManagedSerializableTypeInfoArrayPtr& typeInfo, MonoObject* managedInstance);
+		ManagedSerializableArray(const ConstructPrivately& dummy);
+
+		MonoObject* getManagedInstance() const { return mManagedInstance; }
+
+		static ManagedSerializableArrayPtr create(MonoObject* managedInstance, const ManagedSerializableTypeInfoArrayPtr& typeInfo);
+
+	protected:
+		MonoObject* mManagedInstance;
+		::MonoClass* mElementMonoClass;
+
+		ManagedSerializableTypeInfoArrayPtr mArrayTypeInfo;
+		Vector<ManagedSerializableFieldDataPtr>::type mArrayEntries;
+		
+		Vector<UINT32>::type mNumElements;
+		UINT32 mElemSize;
+
+		void initMonoObjects();
+
+		/**
+		 * @brief	Populates internal field data based on currently active managed instance.
+		 */
+		void serializeManagedInstance();
+
+		/**
+		 * @brief	Creates a new managed instance and populates it with stored field data.
+		 */
+		void deserializeManagedInstance();
+
+		void setFieldData(UINT32 arrayIdx, const ManagedSerializableFieldDataPtr& val);
+		ManagedSerializableFieldDataPtr getFieldData(UINT32 arrayIdx);
+
+		void setValue(UINT32 arrayIdx, void* val);
+
+		UINT32 toSequentialIdx(const Vector<UINT32>::type& idx) const;
+		UINT32 getLength(UINT32 dimension) const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+		
+		static ManagedSerializableArrayPtr createEmpty();
+
+	public:
+		friend class ManagedSerializableArrayRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
 }

SBansheeEngine/Include/BsManagedSerializableArrayRTTI.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmGameObjectManager.h"
+#include "BsManagedSerializableArray.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsMonoManager.h"
+#include "BsMonoClass.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableArrayRTTI : public RTTIType<ManagedSerializableArray, IReflectable, ManagedSerializableArrayRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoArrayPtr getTypeInfo(ManagedSerializableArray* obj)
+		{
+			return obj->mArrayTypeInfo;
+		}
+
+		void setTypeInfo(ManagedSerializableArray* obj, ManagedSerializableTypeInfoArrayPtr val)
+		{
+			obj->mArrayTypeInfo = val;
+		}
+
+		UINT32& getElementSize(ManagedSerializableArray* obj)
+		{
+			return (UINT32)obj->mElemSize;
+		}
+
+		void setElementSize(ManagedSerializableArray* obj, UINT32& numElements)
+		{
+			obj->mElemSize = numElements;
+		}
+
+		UINT32& getNumElements(ManagedSerializableArray* obj, UINT32 arrayIdx)
+		{
+			return (UINT32)obj->mNumElements[arrayIdx];
+		}
+
+		void setNumElements(ManagedSerializableArray* obj, UINT32 arrayIdx, UINT32& numElements)
+		{
+			obj->mNumElements[arrayIdx] = numElements;
+		}
+
+		UINT32 getNumElementsNumEntries(ManagedSerializableArray* obj)
+		{
+			return (UINT32)obj->mNumElements.size();
+		}
+
+		void setNumElementsNumEntries(ManagedSerializableArray* obj, UINT32 numEntries)
+		{
+			obj->mNumElements.resize(numEntries);
+		}
+
+		ManagedSerializableFieldDataPtr getArrayEntry(ManagedSerializableArray* obj, UINT32 arrayIdx)
+		{
+			return obj->mArrayEntries[arrayIdx];
+		}
+
+		void setArrayEntry(ManagedSerializableArray* obj, UINT32 arrayIdx, ManagedSerializableFieldDataPtr val)
+		{
+			obj->mArrayEntries[arrayIdx] = val;
+		}
+
+		UINT32 getNumArrayEntries(ManagedSerializableArray* obj)
+		{
+			return (UINT32)obj->mArrayEntries.size();
+		}
+
+		void setNumArrayEntries(ManagedSerializableArray* obj, UINT32 numEntries)
+		{
+			obj->mArrayEntries.resize(numEntries);
+		}
+
+	public:
+		ManagedSerializableArrayRTTI()
+		{
+			addReflectablePtrField("mArrayTypeInfo", 0, &ManagedSerializableArrayRTTI::getTypeInfo, &ManagedSerializableArrayRTTI::setTypeInfo);
+			addPlainField("mElementSize", 1, &ManagedSerializableArrayRTTI::getElementSize, &ManagedSerializableArrayRTTI::setElementSize);
+			addPlainArrayField("mNumElements", 2, &ManagedSerializableArrayRTTI::getNumElements, &ManagedSerializableArrayRTTI::getNumElementsNumEntries, 
+				&ManagedSerializableArrayRTTI::setNumElements, &ManagedSerializableArrayRTTI::setNumElementsNumEntries);
+			addReflectablePtrArrayField("mArrayEntries", 3, &ManagedSerializableArrayRTTI::getArrayEntry, &ManagedSerializableArrayRTTI::getNumArrayEntries, 
+				&ManagedSerializableArrayRTTI::setArrayEntry, &ManagedSerializableArrayRTTI::setNumArrayEntries);
+		}
+
+		virtual void onSerializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableArray* serializableObject = static_cast<ManagedSerializableArray*>(obj);
+			serializableObject->serializeManagedInstance();
+		}
+
+		virtual void onDeserializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableArray* serializableObject = static_cast<ManagedSerializableArray*>(obj);
+
+			// If we are deserializing a GameObject we need to defer deserializing actual field values
+			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
+			if(GameObjectManager::instance().isGameObjectDeserializationActive())
+				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
+			else
+				serializableObject->deserializeManagedInstance();
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableArray";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_ScriptSerializableArray;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return ManagedSerializableArray::createEmpty();
+		}
+	};
+}

SBansheeEngine/Include/BsScriptSerializableDictionary.h → SBansheeEngine/Include/BsManagedSerializableDictionary.h

@@ -1,78 +1,78 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmIReflectable.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableDictionary : public IReflectable
-	{
-	private:
-		class Enumerator
-		{
-		public:
-			Enumerator(MonoObject* instance, const ScriptSerializableDictionary* parent);
-
-			ScriptSerializableFieldDataPtr getKey() const;
-			ScriptSerializableFieldDataPtr getValue() const;
-
-			bool moveNext();
-
-		private:
-			MonoObject* mInstance;
-			MonoObject* mCurrent;
-			const ScriptSerializableDictionary* mParent;
-		};
-
-		struct ConstructPrivately {};
-
-	public:
-		ScriptSerializableDictionary(const ConstructPrivately& dummy, const ScriptSerializableTypeInfoDictionaryPtr& typeInfo, MonoObject* managedInstance);
-		ScriptSerializableDictionary(const ConstructPrivately& dummy);
-
-		MonoObject* getManagedInstance() const { return mManagedInstance; }
-
-		static ScriptSerializableDictionaryPtr create(MonoObject* managedInstance, const ScriptSerializableTypeInfoDictionaryPtr& typeInfo);
-
-	protected:
-		MonoObject* mManagedInstance;
-
-		MonoMethod* mAddMethod;
-		MonoMethod* mGetEnumerator;
-		MonoMethod* mEnumMoveNext;
-		MonoProperty* mEnumCurrentProp;
-		MonoProperty* mKeyProp;
-		MonoProperty* mValueProp;
-
-		ScriptSerializableTypeInfoDictionaryPtr mDictionaryTypeInfo;
-		Vector<ScriptSerializableFieldDataPtr>::type mKeyEntries;
-		Vector<ScriptSerializableFieldDataPtr>::type mValueEntries;
-
-		void initMonoObjects(MonoClass* dictionaryClass);
-
-		/**
-		 * @brief	Populates internal field data based on currently active managed instance.
-		 */
-		void serializeManagedInstance();
-
-		/**
-		 * @brief	Creates a new managed instance and populates it with stored field data.
-		 */
-		void deserializeManagedInstance();
-
-		void setFieldData(const ScriptSerializableFieldDataPtr& key, const ScriptSerializableFieldDataPtr& val);
-		Enumerator getEnumerator() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-		
-		static ScriptSerializableDictionaryPtr createEmpty();
-
-	public:
-		friend class ScriptSerializableDictionaryRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmIReflectable.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableDictionary : public IReflectable
+	{
+	private:
+		class Enumerator
+		{
+		public:
+			Enumerator(MonoObject* instance, const ManagedSerializableDictionary* parent);
+
+			ManagedSerializableFieldDataPtr getKey() const;
+			ManagedSerializableFieldDataPtr getValue() const;
+
+			bool moveNext();
+
+		private:
+			MonoObject* mInstance;
+			MonoObject* mCurrent;
+			const ManagedSerializableDictionary* mParent;
+		};
+
+		struct ConstructPrivately {};
+
+	public:
+		ManagedSerializableDictionary(const ConstructPrivately& dummy, const ManagedSerializableTypeInfoDictionaryPtr& typeInfo, MonoObject* managedInstance);
+		ManagedSerializableDictionary(const ConstructPrivately& dummy);
+
+		MonoObject* getManagedInstance() const { return mManagedInstance; }
+
+		static ManagedSerializableDictionaryPtr create(MonoObject* managedInstance, const ManagedSerializableTypeInfoDictionaryPtr& typeInfo);
+
+	protected:
+		MonoObject* mManagedInstance;
+
+		MonoMethod* mAddMethod;
+		MonoMethod* mGetEnumerator;
+		MonoMethod* mEnumMoveNext;
+		MonoProperty* mEnumCurrentProp;
+		MonoProperty* mKeyProp;
+		MonoProperty* mValueProp;
+
+		ManagedSerializableTypeInfoDictionaryPtr mDictionaryTypeInfo;
+		Vector<ManagedSerializableFieldDataPtr>::type mKeyEntries;
+		Vector<ManagedSerializableFieldDataPtr>::type mValueEntries;
+
+		void initMonoObjects(MonoClass* dictionaryClass);
+
+		/**
+		 * @brief	Populates internal field data based on currently active managed instance.
+		 */
+		void serializeManagedInstance();
+
+		/**
+		 * @brief	Creates a new managed instance and populates it with stored field data.
+		 */
+		void deserializeManagedInstance();
+
+		void setFieldData(const ManagedSerializableFieldDataPtr& key, const ManagedSerializableFieldDataPtr& val);
+		Enumerator getEnumerator() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+		
+		static ManagedSerializableDictionaryPtr createEmpty();
+
+	public:
+		friend class ManagedSerializableDictionaryRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
 }

SBansheeEngine/Include/BsManagedSerializableDictionaryRTTI.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmGameObjectManager.h"
+#include "BsManagedSerializableDictionary.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsMonoManager.h"
+#include "BsMonoClass.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableDictionaryRTTI : public RTTIType<ManagedSerializableDictionary, IReflectable, ManagedSerializableDictionaryRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoDictionaryPtr getTypeInfo(ManagedSerializableDictionary* obj) { return obj->mDictionaryTypeInfo; }
+		void setTypeInfo(ManagedSerializableDictionary* obj, ManagedSerializableTypeInfoDictionaryPtr val) { obj->mDictionaryTypeInfo = val; }
+
+		ManagedSerializableFieldDataPtr getKeyEntry(ManagedSerializableDictionary* obj, UINT32 arrayIdx) { return obj->mKeyEntries[arrayIdx]; }
+		void setKeyEntry(ManagedSerializableDictionary* obj, UINT32 arrayIdx, ManagedSerializableFieldDataPtr val) { obj->mKeyEntries[arrayIdx] = val; }
+		UINT32 getNumKeyEntries(ManagedSerializableDictionary* obj) { return (UINT32)obj->mKeyEntries.size(); }
+		void setNumKeyEntries(ManagedSerializableDictionary* obj, UINT32 numEntries) { obj->mKeyEntries.resize(numEntries); }
+
+		ManagedSerializableFieldDataPtr getValueEntry(ManagedSerializableDictionary* obj, UINT32 arrayIdx) { return obj->mValueEntries[arrayIdx]; }
+		void setValueEntry(ManagedSerializableDictionary* obj, UINT32 arrayIdx, ManagedSerializableFieldDataPtr val) { obj->mValueEntries[arrayIdx] = val; }
+		UINT32 getNumValueEntries(ManagedSerializableDictionary* obj) { return (UINT32)obj->mValueEntries.size(); }
+		void setNumValueEntries(ManagedSerializableDictionary* obj, UINT32 numEntries) { obj->mValueEntries.resize(numEntries); }
+
+	public:
+		ManagedSerializableDictionaryRTTI()
+		{
+			addReflectablePtrField("mListTypeInfo", 0, &ManagedSerializableDictionaryRTTI::getTypeInfo, &ManagedSerializableDictionaryRTTI::setTypeInfo);
+			addReflectablePtrArrayField("mKeyEntries", 1, &ManagedSerializableDictionaryRTTI::getKeyEntry, &ManagedSerializableDictionaryRTTI::getNumKeyEntries, 
+				&ManagedSerializableDictionaryRTTI::setKeyEntry, &ManagedSerializableDictionaryRTTI::setNumKeyEntries);
+			addReflectablePtrArrayField("mValueEntries", 2, &ManagedSerializableDictionaryRTTI::getValueEntry, &ManagedSerializableDictionaryRTTI::getNumValueEntries, 
+				&ManagedSerializableDictionaryRTTI::setValueEntry, &ManagedSerializableDictionaryRTTI::setNumValueEntries);
+		}
+
+		virtual void onSerializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableDictionary* serializableObject = static_cast<ManagedSerializableDictionary*>(obj);
+			serializableObject->serializeManagedInstance();
+		}
+
+		virtual void onDeserializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableDictionary* serializableObject = static_cast<ManagedSerializableDictionary*>(obj);
+
+			// If we are deserializing a GameObject we need to defer deserializing actual field values
+			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
+			if(GameObjectManager::instance().isGameObjectDeserializationActive())
+				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
+			else
+				serializableObject->deserializeManagedInstance();
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableDictionary";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_ScriptSerializableDictionary;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return ManagedSerializableDictionary::createEmpty();
+		}
+	};
+}

SBansheeEngine/Include/BsScriptSerializableField.h → SBansheeEngine/Include/BsManagedSerializableField.h

@@ -1,384 +1,384 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmIReflectable.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldKey : public IReflectable
-	{
-	public:
-		static ScriptSerializableFieldKeyPtr create(UINT16 typeId, UINT16 fieldId);
-
-		UINT16 mTypeId;
-		UINT16 mFieldId;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataKeyRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldData : public IReflectable
-	{
-	public:
-		static ScriptSerializableFieldDataPtr create(const ScriptSerializableTypeInfoPtr& typeInfo, MonoObject* value);
-		virtual void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo) = 0;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataEntry : public IReflectable
-	{
-	public:
-		static ScriptSerializableFieldDataEntryPtr create(const ScriptSerializableFieldKeyPtr& key, const ScriptSerializableFieldDataPtr& value);
-
-		ScriptSerializableFieldKeyPtr mKey;
-		ScriptSerializableFieldDataPtr mValue;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataEntryRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataBool : public ScriptSerializableFieldData
-	{
-	public:
-		bool value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataBoolRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataChar : public ScriptSerializableFieldData
-	{
-	public:
-		wchar_t value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataCharRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI8 : public ScriptSerializableFieldData
-	{
-	public:
-		INT8 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataI8RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU8 : public ScriptSerializableFieldData
-	{
-	public:
-		UINT8 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataU8RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI16 : public ScriptSerializableFieldData
-	{
-	public:
-		INT16 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataI16RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU16 : public ScriptSerializableFieldData
-	{
-	public:
-		UINT16 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataU16RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI32 : public ScriptSerializableFieldData
-	{
-	public:
-		INT32 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataI32RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU32 : public ScriptSerializableFieldData
-	{
-	public:
-		UINT32 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataU32RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI64 : public ScriptSerializableFieldData
-	{
-	public:
-		INT64 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataI64RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU64 : public ScriptSerializableFieldData
-	{
-	public:
-		UINT64 value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataU64RTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataFloat : public ScriptSerializableFieldData
-	{
-	public:
-		float value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataFloatRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataDouble : public ScriptSerializableFieldData
-	{
-	public:
-		double value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataDoubleRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataString : public ScriptSerializableFieldData
-	{
-	public:
-		WString value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataStringRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataResourceRef : public ScriptSerializableFieldData
-	{
-	public:
-		HResource value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataResourceRefRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataGameObjectRef : public ScriptSerializableFieldData
-	{
-	public:
-		HGameObject value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataGameObjectRefRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataObject : public ScriptSerializableFieldData
-	{
-	public:
-		ScriptSerializableObjectPtr value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataObjectRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataArray : public ScriptSerializableFieldData
-	{
-	public:
-		ScriptSerializableArrayPtr value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataArrayRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataList : public ScriptSerializableFieldData
-	{
-	public:
-		ScriptSerializableListPtr value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataListRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataDictionary : public ScriptSerializableFieldData
-	{
-	public:
-		ScriptSerializableDictionaryPtr value;
-
-		void* getValue(const ScriptSerializableTypeInfoPtr& typeInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
-	public:
-		friend class ScriptSerializableFieldDataDictionaryRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmIReflectable.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldKey : public IReflectable
+	{
+	public:
+		static ManagedSerializableFieldKeyPtr create(UINT16 typeId, UINT16 fieldId);
+
+		UINT16 mTypeId;
+		UINT16 mFieldId;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ScriptSerializableFieldDataKeyRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldData : public IReflectable
+	{
+	public:
+		static ManagedSerializableFieldDataPtr create(const ManagedSerializableTypeInfoPtr& typeInfo, MonoObject* value);
+		virtual void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo) = 0;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataEntry : public IReflectable
+	{
+	public:
+		static ManagedSerializableFieldDataEntryPtr create(const ManagedSerializableFieldKeyPtr& key, const ManagedSerializableFieldDataPtr& value);
+
+		ManagedSerializableFieldKeyPtr mKey;
+		ManagedSerializableFieldDataPtr mValue;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataEntryRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataBool : public ManagedSerializableFieldData
+	{
+	public:
+		bool value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataBoolRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataChar : public ManagedSerializableFieldData
+	{
+	public:
+		wchar_t value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataCharRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI8 : public ManagedSerializableFieldData
+	{
+	public:
+		INT8 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataI8RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU8 : public ManagedSerializableFieldData
+	{
+	public:
+		UINT8 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataU8RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI16 : public ManagedSerializableFieldData
+	{
+	public:
+		INT16 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataI16RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU16 : public ManagedSerializableFieldData
+	{
+	public:
+		UINT16 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataU16RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI32 : public ManagedSerializableFieldData
+	{
+	public:
+		INT32 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataI32RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU32 : public ManagedSerializableFieldData
+	{
+	public:
+		UINT32 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataU32RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI64 : public ManagedSerializableFieldData
+	{
+	public:
+		INT64 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataI64RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU64 : public ManagedSerializableFieldData
+	{
+	public:
+		UINT64 value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataU64RTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataFloat : public ManagedSerializableFieldData
+	{
+	public:
+		float value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataFloatRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataDouble : public ManagedSerializableFieldData
+	{
+	public:
+		double value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataDoubleRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataString : public ManagedSerializableFieldData
+	{
+	public:
+		WString value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataStringRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataResourceRef : public ManagedSerializableFieldData
+	{
+	public:
+		HResource value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataResourceRefRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataGameObjectRef : public ManagedSerializableFieldData
+	{
+	public:
+		HGameObject value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataGameObjectRefRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataObject : public ManagedSerializableFieldData
+	{
+	public:
+		ManagedSerializableObjectPtr value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataObjectRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataArray : public ManagedSerializableFieldData
+	{
+	public:
+		ManagedSerializableArrayPtr value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataArrayRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataList : public ManagedSerializableFieldData
+	{
+	public:
+		ManagedSerializableListPtr value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataListRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataDictionary : public ManagedSerializableFieldData
+	{
+	public:
+		ManagedSerializableDictionaryPtr value;
+
+		void* getValue(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+
+	public:
+		friend class ManagedSerializableFieldDataDictionaryRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
 }

SBansheeEngine/Include/BsManagedSerializableFieldRTTI.h

@@ -0,0 +1,653 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmRTTIType.h"
+#include "BsManagedSerializableField.h"
+#include "CmException.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldKeyRTTI : public RTTIType<ManagedSerializableFieldKey, IReflectable, ManagedSerializableFieldKeyRTTI>
+	{
+	private:
+		UINT16& getTypeId(ManagedSerializableFieldKey* obj) { return obj->mTypeId; }
+		void setTypeId(ManagedSerializableFieldKey* obj, UINT16& val) { obj->mTypeId = val; }
+
+		UINT16& getFieldId(ManagedSerializableFieldKey* obj) { return obj->mFieldId; }
+		void setFieldId(ManagedSerializableFieldKey* obj, UINT16& val) { obj->mFieldId = val; }
+
+	public:
+		ManagedSerializableFieldKeyRTTI()
+		{
+			addPlainField("mTypeId", 0, &ManagedSerializableFieldKeyRTTI::getTypeId, &ManagedSerializableFieldKeyRTTI::setTypeId);
+			addPlainField("mFieldId", 1, &ManagedSerializableFieldKeyRTTI::getFieldId, &ManagedSerializableFieldKeyRTTI::setFieldId);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldKey";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldKey;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldKey>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataRTTI : public RTTIType<ManagedSerializableFieldData, IReflectable, ManagedSerializableFieldDataRTTI>
+	{
+	private:
+
+	public:
+		ManagedSerializableFieldDataRTTI()
+		{
+
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldData";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldData;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			CM_EXCEPT(InvalidStateException, "Cannot instantiate an abstract class.");
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataEntryRTTI : public RTTIType<ManagedSerializableFieldDataEntry, IReflectable, ManagedSerializableFieldDataEntryRTTI>
+	{
+	private:
+		ManagedSerializableFieldKeyPtr getKey(ManagedSerializableFieldDataEntry* obj)	{ return obj->mKey; }
+		void setKey(ManagedSerializableFieldDataEntry* obj, ManagedSerializableFieldKeyPtr val) { obj->mKey = val; }
+
+		ManagedSerializableFieldDataPtr getValue(ManagedSerializableFieldDataEntry* obj) { return obj->mValue; }
+		void setValue(ManagedSerializableFieldDataEntry* obj, ManagedSerializableFieldDataPtr val) { obj->mValue = val; }
+
+	public:
+		ManagedSerializableFieldDataEntryRTTI()
+		{
+			addReflectablePtrField("mKey", 0, &ManagedSerializableFieldDataEntryRTTI::getKey, &ManagedSerializableFieldDataEntryRTTI::setKey);
+			addReflectablePtrField("mValue", 1, &ManagedSerializableFieldDataEntryRTTI::getValue, &ManagedSerializableFieldDataEntryRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataEntry";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataEntry;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataEntry>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataBoolRTTI : public RTTIType<ManagedSerializableFieldDataBool, ManagedSerializableFieldData, ManagedSerializableFieldDataBoolRTTI>
+	{
+	private:
+		bool& getValue(ManagedSerializableFieldDataBool* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataBool* obj, bool& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataBoolRTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataBoolRTTI::getValue, &ManagedSerializableFieldDataBoolRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataBool";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataBool;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataBool>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataCharRTTI : public RTTIType<ManagedSerializableFieldDataChar, ManagedSerializableFieldData, ManagedSerializableFieldDataCharRTTI>
+	{
+	private:
+		wchar_t& getValue(ManagedSerializableFieldDataChar* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataChar* obj, wchar_t& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataCharRTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataCharRTTI::getValue, &ManagedSerializableFieldDataCharRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataChar";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataChar;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataBool>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI8RTTI : public RTTIType<ManagedSerializableFieldDataI8, ManagedSerializableFieldData, ManagedSerializableFieldDataI8RTTI>
+	{
+	private:
+		INT8& getValue(ManagedSerializableFieldDataI8* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataI8* obj, INT8& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataI8RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataI8RTTI::getValue, &ManagedSerializableFieldDataI8RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataI8";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataI8;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataI8>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU8RTTI : public RTTIType<ManagedSerializableFieldDataU8, ManagedSerializableFieldData, ManagedSerializableFieldDataU8RTTI>
+	{
+	private:
+		UINT8& getValue(ManagedSerializableFieldDataU8* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataU8* obj, UINT8& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataU8RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataU8RTTI::getValue, &ManagedSerializableFieldDataU8RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataU8";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataU8;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataU8>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI16RTTI : public RTTIType<ManagedSerializableFieldDataI16, ManagedSerializableFieldData, ManagedSerializableFieldDataI16RTTI>
+	{
+	private:
+		INT16& getValue(ManagedSerializableFieldDataI16* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataI16* obj, INT16& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataI16RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataI16RTTI::getValue, &ManagedSerializableFieldDataI16RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataI16";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataI16;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataI16>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU16RTTI : public RTTIType<ManagedSerializableFieldDataU16, ManagedSerializableFieldData, ManagedSerializableFieldDataU16RTTI>
+	{
+	private:
+		UINT16& getValue(ManagedSerializableFieldDataU16* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataU16* obj, UINT16& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataU16RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataU16RTTI::getValue, &ManagedSerializableFieldDataU16RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataU16";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataU16;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataU16>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI32RTTI : public RTTIType<ManagedSerializableFieldDataI32, ManagedSerializableFieldData, ManagedSerializableFieldDataI32RTTI>
+	{
+	private:
+		INT32& getValue(ManagedSerializableFieldDataI32* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataI32* obj, INT32& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataI32RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataI32RTTI::getValue, &ManagedSerializableFieldDataI32RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataI32";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataI32;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataI32>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU32RTTI : public RTTIType<ManagedSerializableFieldDataU32, ManagedSerializableFieldData, ManagedSerializableFieldDataU32RTTI>
+	{
+	private:
+		UINT32& getValue(ManagedSerializableFieldDataU32* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataU32* obj, UINT32& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataU32RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataU32RTTI::getValue, &ManagedSerializableFieldDataU32RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataU32";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataU32;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataU32>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataI64RTTI : public RTTIType<ManagedSerializableFieldDataI64, ManagedSerializableFieldData, ManagedSerializableFieldDataI64RTTI>
+	{
+	private:
+		INT64& getValue(ManagedSerializableFieldDataI64* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataI64* obj, INT64& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataI64RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataI64RTTI::getValue, &ManagedSerializableFieldDataI64RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataI64";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataI64;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataI64>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataU64RTTI : public RTTIType<ManagedSerializableFieldDataU64, ManagedSerializableFieldData, ManagedSerializableFieldDataU64RTTI>
+	{
+	private:
+		UINT64& getValue(ManagedSerializableFieldDataU64* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataU64* obj, UINT64& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataU64RTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataU64RTTI::getValue, &ManagedSerializableFieldDataU64RTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataU64";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataU64;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataU64>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataFloatRTTI : public RTTIType<ManagedSerializableFieldDataFloat, ManagedSerializableFieldData, ManagedSerializableFieldDataFloatRTTI>
+	{
+	private:
+		float& getValue(ManagedSerializableFieldDataFloat* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataFloat* obj, float& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataFloatRTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataFloatRTTI::getValue, &ManagedSerializableFieldDataFloatRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataFloat";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataFloat;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataFloat>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataDoubleRTTI : public RTTIType<ManagedSerializableFieldDataDouble, ManagedSerializableFieldData, ManagedSerializableFieldDataDoubleRTTI>
+	{
+	private:
+		double& getValue(ManagedSerializableFieldDataDouble* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataDouble* obj, double& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataDoubleRTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataDoubleRTTI::getValue, &ManagedSerializableFieldDataDoubleRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataDouble";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataDouble;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataDouble>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataStringRTTI : public RTTIType<ManagedSerializableFieldDataString, ManagedSerializableFieldData, ManagedSerializableFieldDataStringRTTI>
+	{
+	private:
+		WString& getValue(ManagedSerializableFieldDataString* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataString* obj, WString& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataStringRTTI()
+		{
+			addPlainField("mValue", 0, &ManagedSerializableFieldDataStringRTTI::getValue, &ManagedSerializableFieldDataStringRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataString";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataString;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataString>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataResourceRefRTTI : public RTTIType<ManagedSerializableFieldDataResourceRef, ManagedSerializableFieldData, ManagedSerializableFieldDataResourceRefRTTI>
+	{
+	private:
+		HResource& getValue(ManagedSerializableFieldDataResourceRef* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataResourceRef* obj, HResource& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataResourceRefRTTI()
+		{
+			addReflectableField("mValue", 0, &ManagedSerializableFieldDataResourceRefRTTI::getValue, &ManagedSerializableFieldDataResourceRefRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataResourceRef";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataResourceRef;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataResourceRef>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataGameObjectRefRTTI : public RTTIType<ManagedSerializableFieldDataGameObjectRef, ManagedSerializableFieldData, ManagedSerializableFieldDataGameObjectRefRTTI>
+	{
+	private:
+		HGameObject& getValue(ManagedSerializableFieldDataGameObjectRef* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataGameObjectRef* obj, HGameObject& val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataGameObjectRefRTTI()
+		{
+			addReflectableField("mValue", 0, &ManagedSerializableFieldDataGameObjectRefRTTI::getValue, &ManagedSerializableFieldDataGameObjectRefRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataGameObjectRef";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataGameObjectRef;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataGameObjectRef>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataObjectRTTI : public RTTIType<ManagedSerializableFieldDataObject, ManagedSerializableFieldData, ManagedSerializableFieldDataObjectRTTI>
+	{
+	private:
+		ManagedSerializableObjectPtr getValue(ManagedSerializableFieldDataObject* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataObject* obj, ManagedSerializableObjectPtr val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataObjectRTTI()
+		{
+			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataObjectRTTI::getValue, &ManagedSerializableFieldDataObjectRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataObject";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataObject;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataObject>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataArrayRTTI : public RTTIType<ManagedSerializableFieldDataArray, ManagedSerializableFieldData, ManagedSerializableFieldDataArrayRTTI>
+	{
+	private:
+		ManagedSerializableArrayPtr getValue(ManagedSerializableFieldDataArray* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataArray* obj, ManagedSerializableArrayPtr val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataArrayRTTI()
+		{
+			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataArrayRTTI::getValue, &ManagedSerializableFieldDataArrayRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataArray";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataArray;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataArray>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataListRTTI : public RTTIType<ManagedSerializableFieldDataList, ManagedSerializableFieldData, ManagedSerializableFieldDataListRTTI>
+	{
+	private:
+		ManagedSerializableListPtr getValue(ManagedSerializableFieldDataList* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataList* obj, ManagedSerializableListPtr val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataListRTTI()
+		{
+			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataListRTTI::getValue, &ManagedSerializableFieldDataListRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataList";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataList;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataList>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldDataDictionaryRTTI : public RTTIType<ManagedSerializableFieldDataDictionary, ManagedSerializableFieldData, ManagedSerializableFieldDataDictionaryRTTI>
+	{
+	private:
+		ManagedSerializableDictionaryPtr getValue(ManagedSerializableFieldDataDictionary* obj) { return obj->value; }
+		void setValue(ManagedSerializableFieldDataDictionary* obj, ManagedSerializableDictionaryPtr val) { obj->value = val; }
+
+	public:
+		ManagedSerializableFieldDataDictionaryRTTI()
+		{
+			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataDictionaryRTTI::getValue, &ManagedSerializableFieldDataDictionaryRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "SerializableFieldDataDictionary";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldDataDictionary;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableFieldDataDictionary>();
+		}
+	};
+}

SBansheeEngine/Include/BsScriptSerializableList.h → SBansheeEngine/Include/BsManagedSerializableList.h

@@ -1,63 +1,63 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmIReflectable.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableList : public IReflectable
-	{
-	private:
-		struct ConstructPrivately {};
-
-	public:
-		ScriptSerializableList(const ConstructPrivately& dummy, const ScriptSerializableTypeInfoListPtr& typeInfo, MonoObject* managedInstance);
-		ScriptSerializableList(const ConstructPrivately& dummy);
-
-		MonoObject* getManagedInstance() const { return mManagedInstance; }
-
-		static ScriptSerializableListPtr create(MonoObject* managedInstance, const ScriptSerializableTypeInfoListPtr& typeInfo);
-
-	protected:
-		MonoObject* mManagedInstance;
-
-		MonoMethod* mAddMethod;
-		MonoProperty* mItemProp;
-		MonoProperty* mCountProp;
-
-		ScriptSerializableTypeInfoListPtr mListTypeInfo;
-		Vector<ScriptSerializableFieldDataPtr>::type mListEntries;
-		
-		UINT32 mNumElements;
-
-		void initMonoObjects(MonoClass* listClass);
-
-		/**
-		 * @brief	Populates internal field data based on currently active managed instance.
-		 */
-		void serializeManagedInstance();
-
-		/**
-		 * @brief	Creates a new managed instance and populates it with stored field data.
-		 */
-		void deserializeManagedInstance();
-
-		void setFieldData(UINT32 arrayIdx, const ScriptSerializableFieldDataPtr& val);
-		void addFieldData(const ScriptSerializableFieldDataPtr& val);
-		ScriptSerializableFieldDataPtr getFieldData(UINT32 arrayIdx);
-
-		UINT32 getLength() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-		
-		static ScriptSerializableListPtr createEmpty();
-
-	public:
-		friend class ScriptSerializableListRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmIReflectable.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableList : public IReflectable
+	{
+	private:
+		struct ConstructPrivately {};
+
+	public:
+		ManagedSerializableList(const ConstructPrivately& dummy, const ManagedSerializableTypeInfoListPtr& typeInfo, MonoObject* managedInstance);
+		ManagedSerializableList(const ConstructPrivately& dummy);
+
+		MonoObject* getManagedInstance() const { return mManagedInstance; }
+
+		static ManagedSerializableListPtr create(MonoObject* managedInstance, const ManagedSerializableTypeInfoListPtr& typeInfo);
+
+	protected:
+		MonoObject* mManagedInstance;
+
+		MonoMethod* mAddMethod;
+		MonoProperty* mItemProp;
+		MonoProperty* mCountProp;
+
+		ManagedSerializableTypeInfoListPtr mListTypeInfo;
+		Vector<ManagedSerializableFieldDataPtr>::type mListEntries;
+		
+		UINT32 mNumElements;
+
+		void initMonoObjects(MonoClass* listClass);
+
+		/**
+		 * @brief	Populates internal field data based on currently active managed instance.
+		 */
+		void serializeManagedInstance();
+
+		/**
+		 * @brief	Creates a new managed instance and populates it with stored field data.
+		 */
+		void deserializeManagedInstance();
+
+		void setFieldData(UINT32 arrayIdx, const ManagedSerializableFieldDataPtr& val);
+		void addFieldData(const ManagedSerializableFieldDataPtr& val);
+		ManagedSerializableFieldDataPtr getFieldData(UINT32 arrayIdx);
+
+		UINT32 getLength() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+		
+		static ManagedSerializableListPtr createEmpty();
+
+	public:
+		friend class ManagedSerializableListRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
 }

SBansheeEngine/Include/BsManagedSerializableListRTTI.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmGameObjectManager.h"
+#include "BsManagedSerializableList.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsMonoManager.h"
+#include "BsMonoClass.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableListRTTI : public RTTIType<ManagedSerializableList, IReflectable, ManagedSerializableListRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoListPtr getTypeInfo(ManagedSerializableList* obj)
+		{
+			return obj->mListTypeInfo;
+		}
+
+		void setTypeInfo(ManagedSerializableList* obj, ManagedSerializableTypeInfoListPtr val)
+		{
+			obj->mListTypeInfo = val;
+		}
+
+		UINT32& getNumElements(ManagedSerializableList* obj)
+		{
+			return (UINT32)obj->mNumElements;
+		}
+
+		void setNumElements(ManagedSerializableList* obj, UINT32& numElements)
+		{
+			obj->mNumElements = numElements;
+		}
+
+		ManagedSerializableFieldDataPtr getListEntry(ManagedSerializableList* obj, UINT32 arrayIdx)
+		{
+			return obj->mListEntries[arrayIdx];
+		}
+
+		void setListEntry(ManagedSerializableList* obj, UINT32 arrayIdx, ManagedSerializableFieldDataPtr val)
+		{
+			obj->mListEntries[arrayIdx] = val;
+		}
+
+		UINT32 getNumListEntries(ManagedSerializableList* obj)
+		{
+			return (UINT32)obj->mListEntries.size();
+		}
+
+		void setNumListEntries(ManagedSerializableList* obj, UINT32 numEntries)
+		{
+			obj->mListEntries.resize(numEntries);
+		}
+
+	public:
+		ManagedSerializableListRTTI()
+		{
+			addReflectablePtrField("mListTypeInfo", 0, &ManagedSerializableListRTTI::getTypeInfo, &ManagedSerializableListRTTI::setTypeInfo);
+			addPlainField("mNumElements", 1, &ManagedSerializableListRTTI::getNumElements, &ManagedSerializableListRTTI::setNumElements);
+			addReflectablePtrArrayField("mListEntries", 2, &ManagedSerializableListRTTI::getListEntry, &ManagedSerializableListRTTI::getNumListEntries, 
+				&ManagedSerializableListRTTI::setListEntry, &ManagedSerializableListRTTI::setNumListEntries);
+		}
+
+		virtual void onSerializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableList* serializableObject = static_cast<ManagedSerializableList*>(obj);
+			serializableObject->serializeManagedInstance();
+		}
+
+		virtual void onDeserializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableList* serializableObject = static_cast<ManagedSerializableList*>(obj);
+
+			// If we are deserializing a GameObject we need to defer deserializing actual field values
+			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
+			if(GameObjectManager::instance().isGameObjectDeserializationActive())
+				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
+			else
+				serializableObject->deserializeManagedInstance();
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableList";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_ScriptSerializableList;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return ManagedSerializableList::createEmpty();
+		}
+	};
+}

SBansheeEngine/Include/BsScriptSerializableObject.h → SBansheeEngine/Include/BsManagedSerializableObject.h

@@ -1,51 +1,51 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmIReflectable.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableObject : public IReflectable
-	{
-	private:
-		struct ConstructPrivately {};
-
-	public:
-		ScriptSerializableObject(const ConstructPrivately& dummy, ScriptSerializableObjectInfoPtr objInfo, MonoObject* managedInstance);
-		ScriptSerializableObject(const ConstructPrivately& dummy);
-
-		MonoObject* getManagedInstance() const { return mManagedInstance; }
-
-		static ScriptSerializableObjectPtr create(MonoObject* managedInstance);
-
-	protected:
-		ScriptSerializableObjectInfoPtr mObjInfo;
-		MonoObject* mManagedInstance;
-		Vector<ScriptSerializableFieldDataEntryPtr>::type mFieldEntries;
-
-		/**
-		 * @brief	Populates internal field data based on currently active managed instance.
-		 */
-		void serializeManagedInstance();
-
-		/**
-		 * @brief	Creates a new managed instance and populates it with stored field data.
-		 */
-		void deserializeManagedInstance();
-
-		void setFieldData(const ScriptSerializableFieldInfoPtr& fieldInfo, const ScriptSerializableFieldDataPtr& val);
-		ScriptSerializableFieldDataPtr getFieldData(const ScriptSerializableFieldInfoPtr& fieldInfo);
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-		
-		static ScriptSerializableObjectPtr createEmpty();
-
-	public:
-		friend class ScriptSerializableObjectRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmIReflectable.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableObject : public IReflectable
+	{
+	private:
+		struct ConstructPrivately {};
+
+	public:
+		ManagedSerializableObject(const ConstructPrivately& dummy, ManagedSerializableObjectInfoPtr objInfo, MonoObject* managedInstance);
+		ManagedSerializableObject(const ConstructPrivately& dummy);
+
+		MonoObject* getManagedInstance() const { return mManagedInstance; }
+
+		static ManagedSerializableObjectPtr create(MonoObject* managedInstance);
+
+	protected:
+		ManagedSerializableObjectInfoPtr mObjInfo;
+		MonoObject* mManagedInstance;
+		Vector<ManagedSerializableFieldDataEntryPtr>::type mFieldEntries;
+
+		/**
+		 * @brief	Populates internal field data based on currently active managed instance.
+		 */
+		void serializeManagedInstance();
+
+		/**
+		 * @brief	Creates a new managed instance and populates it with stored field data.
+		 */
+		void deserializeManagedInstance();
+
+		void setFieldData(const ManagedSerializableFieldInfoPtr& fieldInfo, const ManagedSerializableFieldDataPtr& val);
+		ManagedSerializableFieldDataPtr getFieldData(const ManagedSerializableFieldInfoPtr& fieldInfo);
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+		
+		static ManagedSerializableObjectPtr createEmpty();
+
+	public:
+		friend class ManagedSerializableObjectRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
 }

SBansheeEngine/Include/BsScriptSerializableObjectInfo.h → SBansheeEngine/Include/BsManagedSerializableObjectInfo.h

@@ -1,221 +1,221 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmIReflectable.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	enum class ScriptPrimitiveType
-	{
-		Bool,
-		Char,
-		I8,
-		U8,
-		I16,
-		U16,
-		I32,
-		U32,
-		I64,
-		U64,
-		Float,
-		Double,
-		String,
-		TextureRef,
-		SpriteTextureRef,
-		SceneObjectRef,
-		ComponentRef
-	};
-
-	enum class ScriptFieldFlags
-	{
-		Serializable = 0x01,
-		Inspectable = 0x02
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfo : public IReflectable
-	{
-	public:
-		virtual ~ScriptSerializableTypeInfo() {}
-
-		virtual bool matches(const ScriptSerializableTypeInfoPtr& typeInfo) const = 0;
-		virtual bool isTypeLoaded() const = 0;
-
-		virtual ::MonoClass* getMonoClass() const = 0;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableTypeInfoRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoPrimitive : public ScriptSerializableTypeInfo
-	{
-	public:
-		ScriptPrimitiveType mType;
-
-		bool matches(const ScriptSerializableTypeInfoPtr& typeInfo) const;
-		bool isTypeLoaded() const;
-
-		::MonoClass* getMonoClass() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableTypeInfoPrimitiveRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoObject : public ScriptSerializableTypeInfo
-	{
-	public:
-		String mTypeNamespace;
-		String mTypeName;
-		bool mValueType;
-
-		bool matches(const ScriptSerializableTypeInfoPtr& typeInfo) const;
-		bool isTypeLoaded() const;
-
-		::MonoClass* getMonoClass() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableTypeInfoObjectRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoArray : public ScriptSerializableTypeInfo
-	{
-	public:
-		ScriptSerializableTypeInfoPtr mElementType;
-		UINT32 mRank;
-
-		bool matches(const ScriptSerializableTypeInfoPtr& typeInfo) const;
-		bool isTypeLoaded() const;
-
-		::MonoClass* getMonoClass() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableTypeInfoArrayRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoList : public ScriptSerializableTypeInfo
-	{
-	public:
-		ScriptSerializableTypeInfoPtr mElementType;
-
-		bool matches(const ScriptSerializableTypeInfoPtr& typeInfo) const;
-		bool isTypeLoaded() const;
-
-		::MonoClass* getMonoClass() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableTypeInfoListRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoDictionary : public ScriptSerializableTypeInfo
-	{
-	public:
-		ScriptSerializableTypeInfoPtr mKeyType;
-		ScriptSerializableTypeInfoPtr mValueType;
-
-		bool matches(const ScriptSerializableTypeInfoPtr& typeInfo) const;
-		bool isTypeLoaded() const;
-
-		::MonoClass* getMonoClass() const;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableTypeInfoDictionaryRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldInfo : public IReflectable
-	{
-	public:
-		ScriptSerializableFieldInfo();
-
-		String mName;
-		UINT32 mFieldId;
-
-		ScriptSerializableTypeInfoPtr mTypeInfo;
-		ScriptFieldFlags mFlags;
-
-		MonoField* mMonoField;
-
-		bool isSerializable() const { return ((UINT32)mFlags & (UINT32)ScriptFieldFlags::Serializable) != 0; }
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableFieldInfoRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableObjectInfo : public IReflectable
-	{
-	public:
-		ScriptSerializableObjectInfo();
-
-		ScriptSerializableTypeInfoObjectPtr mTypeInfo;
-		UINT32 mTypeId;
-
-		MonoClass* mMonoClass;
-
-		UnorderedMap<String, UINT32>::type mFieldNameToId;
-		UnorderedMap<UINT32, std::shared_ptr<ScriptSerializableFieldInfo>>::type mFields;
-
-		std::shared_ptr<ScriptSerializableObjectInfo> mBaseClass;
-		Vector<std::weak_ptr<ScriptSerializableObjectInfo>>::type mDerivedClasses;
-
-		String getFullTypeName() const { return mTypeInfo->mTypeNamespace + "." + mTypeInfo->mTypeName; }
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableObjectInfoRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableAssemblyInfo : public IReflectable
-	{
-	public:
-		String mName;
-
-		UnorderedMap<String, UINT32>::type mTypeNameToId;
-		UnorderedMap<UINT32, std::shared_ptr<ScriptSerializableObjectInfo>>::type mObjectInfos;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ScriptSerializableAssemblyInfoRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
-	};
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmIReflectable.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	enum class ScriptPrimitiveType
+	{
+		Bool,
+		Char,
+		I8,
+		U8,
+		I16,
+		U16,
+		I32,
+		U32,
+		I64,
+		U64,
+		Float,
+		Double,
+		String,
+		TextureRef,
+		SpriteTextureRef,
+		SceneObjectRef,
+		ComponentRef
+	};
+
+	enum class ScriptFieldFlags
+	{
+		Serializable = 0x01,
+		Inspectable = 0x02
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfo : public IReflectable
+	{
+	public:
+		virtual ~ManagedSerializableTypeInfo() {}
+
+		virtual bool matches(const ManagedSerializableTypeInfoPtr& typeInfo) const = 0;
+		virtual bool isTypeLoaded() const = 0;
+
+		virtual ::MonoClass* getMonoClass() const = 0;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableTypeInfoRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoPrimitive : public ManagedSerializableTypeInfo
+	{
+	public:
+		ScriptPrimitiveType mType;
+
+		bool matches(const ManagedSerializableTypeInfoPtr& typeInfo) const;
+		bool isTypeLoaded() const;
+
+		::MonoClass* getMonoClass() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableTypeInfoPrimitiveRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoObject : public ManagedSerializableTypeInfo
+	{
+	public:
+		String mTypeNamespace;
+		String mTypeName;
+		bool mValueType;
+
+		bool matches(const ManagedSerializableTypeInfoPtr& typeInfo) const;
+		bool isTypeLoaded() const;
+
+		::MonoClass* getMonoClass() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableTypeInfoObjectRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoArray : public ManagedSerializableTypeInfo
+	{
+	public:
+		ManagedSerializableTypeInfoPtr mElementType;
+		UINT32 mRank;
+
+		bool matches(const ManagedSerializableTypeInfoPtr& typeInfo) const;
+		bool isTypeLoaded() const;
+
+		::MonoClass* getMonoClass() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableTypeInfoArrayRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoList : public ManagedSerializableTypeInfo
+	{
+	public:
+		ManagedSerializableTypeInfoPtr mElementType;
+
+		bool matches(const ManagedSerializableTypeInfoPtr& typeInfo) const;
+		bool isTypeLoaded() const;
+
+		::MonoClass* getMonoClass() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableTypeInfoListRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoDictionary : public ManagedSerializableTypeInfo
+	{
+	public:
+		ManagedSerializableTypeInfoPtr mKeyType;
+		ManagedSerializableTypeInfoPtr mValueType;
+
+		bool matches(const ManagedSerializableTypeInfoPtr& typeInfo) const;
+		bool isTypeLoaded() const;
+
+		::MonoClass* getMonoClass() const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableTypeInfoDictionaryRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldInfo : public IReflectable
+	{
+	public:
+		ManagedSerializableFieldInfo();
+
+		String mName;
+		UINT32 mFieldId;
+
+		ManagedSerializableTypeInfoPtr mTypeInfo;
+		ScriptFieldFlags mFlags;
+
+		MonoField* mMonoField;
+
+		bool isSerializable() const { return ((UINT32)mFlags & (UINT32)ScriptFieldFlags::Serializable) != 0; }
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableFieldInfoRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableObjectInfo : public IReflectable
+	{
+	public:
+		ManagedSerializableObjectInfo();
+
+		ScriptSerializableTypeInfoObjectPtr mTypeInfo;
+		UINT32 mTypeId;
+
+		MonoClass* mMonoClass;
+
+		UnorderedMap<String, UINT32>::type mFieldNameToId;
+		UnorderedMap<UINT32, std::shared_ptr<ManagedSerializableFieldInfo>>::type mFields;
+
+		std::shared_ptr<ManagedSerializableObjectInfo> mBaseClass;
+		Vector<std::weak_ptr<ManagedSerializableObjectInfo>>::type mDerivedClasses;
+
+		String getFullTypeName() const { return mTypeInfo->mTypeNamespace + "." + mTypeInfo->mTypeName; }
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableObjectInfoRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableAssemblyInfo : public IReflectable
+	{
+	public:
+		String mName;
+
+		UnorderedMap<String, UINT32>::type mTypeNameToId;
+		UnorderedMap<UINT32, std::shared_ptr<ManagedSerializableObjectInfo>>::type mObjectInfos;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ManagedSerializableAssemblyInfoRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
 }

SBansheeEngine/Include/BsManagedSerializableObjectInfoRTTI.h

@@ -0,0 +1,465 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmRTTIType.h"
+#include "BsManagedSerializableObjectInfo.h"
+#include "CmException.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableAssemblyInfoRTTI : public RTTIType<ManagedSerializableAssemblyInfo, IReflectable, ManagedSerializableAssemblyInfoRTTI>
+	{
+	private:
+		String& getName(ManagedSerializableAssemblyInfo* obj)
+		{
+			return obj->mName;
+		}
+
+		void setName(ManagedSerializableAssemblyInfo* obj, String& val)
+		{
+			obj->mName = val;
+		}
+
+		ManagedSerializableObjectInfoPtr getSerializableObjectInfo(ManagedSerializableAssemblyInfo* obj, UINT32 idx) 
+		{ 
+			auto iter = obj->mObjectInfos.begin();
+			for(UINT32 i = 0; i < idx; i++)
+				iter++;
+
+			return iter->second;
+		}
+
+		void setSerializableObjectInfo(ManagedSerializableAssemblyInfo* obj, UINT32 idx, ManagedSerializableObjectInfoPtr val) 
+		{ 
+			obj->mTypeNameToId[val->getFullTypeName()] = val->mTypeId;
+			obj->mObjectInfos[val->mTypeId] = val;
+		}
+		
+		UINT32 getSerializableObjectInfoArraySize(ManagedSerializableAssemblyInfo* obj) { return (UINT32)obj->mObjectInfos.size(); }
+		void setSerializableObjectInfoArraySize(ManagedSerializableAssemblyInfo* obj, UINT32 size) {  }
+
+	public:
+		ManagedSerializableAssemblyInfoRTTI()
+		{
+			addPlainField("mName", 0, &ManagedSerializableAssemblyInfoRTTI::getName, &ManagedSerializableAssemblyInfoRTTI::setName);
+			addReflectablePtrArrayField("mObjectInfos", 1, &ManagedSerializableAssemblyInfoRTTI::getSerializableObjectInfo, 
+				&ManagedSerializableAssemblyInfoRTTI::getSerializableObjectInfoArraySize, &ManagedSerializableAssemblyInfoRTTI::setSerializableObjectInfo, 
+				&ManagedSerializableAssemblyInfoRTTI::setSerializableObjectInfoArraySize);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableAssemblyInfo";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableAssemblyInfo;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableAssemblyInfo>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableObjectInfoRTTI : public RTTIType<ManagedSerializableObjectInfo, IReflectable, ManagedSerializableObjectInfoRTTI>
+	{
+	private:
+		ScriptSerializableTypeInfoObjectPtr getTypeInfo(ManagedSerializableObjectInfo* obj)
+		{
+			return obj->mTypeInfo;
+		}
+
+		void setTypeInfo(ManagedSerializableObjectInfo* obj, ScriptSerializableTypeInfoObjectPtr val)
+		{
+			obj->mTypeInfo = val;
+		}
+
+		UINT32& getTypeId(ManagedSerializableObjectInfo* obj)
+		{
+			return obj->mTypeId;
+		}
+
+		void setTypeId(ManagedSerializableObjectInfo* obj, UINT32& val)
+		{
+			obj->mTypeId = val;
+		}
+
+		ManagedSerializableObjectInfoPtr getBaseClass(ManagedSerializableObjectInfo* obj)
+		{
+			return obj->mBaseClass;
+		}
+
+		void setBaseClass(ManagedSerializableObjectInfo* obj, ManagedSerializableObjectInfoPtr val)
+		{
+			obj->mBaseClass = val;
+		}
+
+		ManagedSerializableFieldInfoPtr getSerializableFieldInfo(ManagedSerializableObjectInfo* obj, UINT32 idx) 
+		{ 
+			auto iter = obj->mFields.begin();
+			for(UINT32 i = 0; i < idx; i++)
+				iter++;
+
+			return iter->second;
+		}
+
+		void setSerializableFieldInfo(ManagedSerializableObjectInfo* obj, UINT32 idx, ManagedSerializableFieldInfoPtr val) 
+		{ 
+			obj->mFieldNameToId[val->mName] = val->mFieldId;
+			obj->mFields[val->mFieldId] = val;
+		}
+
+		UINT32 getSerializableFieldInfoArraySize(ManagedSerializableObjectInfo* obj) { return (UINT32)obj->mFields.size(); }
+		void setSerializableFieldInfoArraySize(ManagedSerializableObjectInfo* obj, UINT32 size) {  }
+
+	public:
+		ManagedSerializableObjectInfoRTTI()
+		{
+			addReflectablePtrField("mTypeInfo", 0, &ManagedSerializableObjectInfoRTTI::getTypeInfo, &ManagedSerializableObjectInfoRTTI::setTypeInfo);
+			addPlainField("mTypeId", 1, &ManagedSerializableObjectInfoRTTI::getTypeId, &ManagedSerializableObjectInfoRTTI::setTypeId);
+			addReflectablePtrField("mBaseClass", 2, &ManagedSerializableObjectInfoRTTI::getBaseClass, &ManagedSerializableObjectInfoRTTI::setBaseClass);
+
+			addReflectablePtrArrayField("mFields", 3, &ManagedSerializableObjectInfoRTTI::getSerializableFieldInfo, 
+				&ManagedSerializableObjectInfoRTTI::getSerializableFieldInfoArraySize, &ManagedSerializableObjectInfoRTTI::setSerializableFieldInfo, 
+				&ManagedSerializableObjectInfoRTTI::setSerializableFieldInfoArraySize);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableObjectInfo";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableObjectInfo;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableObjectInfo>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableFieldInfoRTTI : public RTTIType<ManagedSerializableFieldInfo, IReflectable, ManagedSerializableFieldInfoRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoPtr getTypeInfo(ManagedSerializableFieldInfo* obj)
+		{
+			return obj->mTypeInfo;
+		}
+
+		void setTypeInfo(ManagedSerializableFieldInfo* obj, ManagedSerializableTypeInfoPtr val)
+		{
+			obj->mTypeInfo = val;
+		}
+
+		String& getName(ManagedSerializableFieldInfo* obj)
+		{
+			return obj->mName;
+		}
+
+		void setName(ManagedSerializableFieldInfo* obj, String& val)
+		{
+			obj->mName = val;
+		}
+
+		UINT32& getFieldId(ManagedSerializableFieldInfo* obj)
+		{
+			return obj->mFieldId;
+		}
+
+		void setFieldId(ManagedSerializableFieldInfo* obj, UINT32& val)
+		{
+			obj->mFieldId = val;
+		}
+
+		UINT32& getFlags(ManagedSerializableFieldInfo* obj)
+		{
+			return (UINT32&)obj->mFlags;
+		}
+
+		void setFlags(ManagedSerializableFieldInfo* obj, UINT32& val)
+		{
+			obj->mFlags = (ScriptFieldFlags)val;
+		}
+
+	public:
+		ManagedSerializableFieldInfoRTTI()
+		{
+			addPlainField("mName", 0, &ManagedSerializableFieldInfoRTTI::getName, &ManagedSerializableFieldInfoRTTI::setName);
+			addReflectablePtrField("mTypeInfo", 1, &ManagedSerializableFieldInfoRTTI::getTypeInfo, &ManagedSerializableFieldInfoRTTI::setTypeInfo);
+			addPlainField("mFieldId", 2, &ManagedSerializableFieldInfoRTTI::getFieldId, &ManagedSerializableFieldInfoRTTI::setFieldId);
+			addPlainField("mFlags", 3, &ManagedSerializableFieldInfoRTTI::getFlags, &ManagedSerializableFieldInfoRTTI::setFlags);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableFieldInfo";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableFieldInfo;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{return cm_shared_ptr<ManagedSerializableFieldInfo>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoRTTI : public RTTIType<ManagedSerializableTypeInfo, IReflectable, ManagedSerializableTypeInfoRTTI>
+	{
+	private:
+
+	public:
+		ManagedSerializableTypeInfoRTTI()
+		{
+
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableTypeInfo";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableTypeInfo;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			CM_EXCEPT(InvalidStateException, "Cannot instantiate an abstract class");
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoPrimitiveRTTI : public RTTIType<ManagedSerializableTypeInfoPrimitive, ManagedSerializableTypeInfo, ManagedSerializableTypeInfoPrimitiveRTTI>
+	{
+	private:
+		ScriptPrimitiveType& getType(ManagedSerializableTypeInfoPrimitive* obj)
+		{
+			return obj->mType;
+		}
+
+		void setType(ManagedSerializableTypeInfoPrimitive* obj, ScriptPrimitiveType& val)
+		{
+			obj->mType = val;
+		}
+
+	public:
+		ManagedSerializableTypeInfoPrimitiveRTTI()
+		{
+			addPlainField("mType", 0, &ManagedSerializableTypeInfoPrimitiveRTTI::getType, &ManagedSerializableTypeInfoPrimitiveRTTI::setType);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableTypeInfoPrimitive";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableTypeInfoPrimitive;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoObjectRTTI : public RTTIType<ManagedSerializableTypeInfoObject, ManagedSerializableTypeInfo, ManagedSerializableTypeInfoObjectRTTI>
+	{
+	private:
+		String& getTypeNamespace(ManagedSerializableTypeInfoObject* obj)
+		{
+			return obj->mTypeNamespace;
+		}
+
+		void setTypeNamespace(ManagedSerializableTypeInfoObject* obj, String& val)
+		{
+			obj->mTypeNamespace = val;
+		}
+
+		String& getTypeName(ManagedSerializableTypeInfoObject* obj)
+		{
+			return obj->mTypeName;
+		}
+
+		void setTypeName(ManagedSerializableTypeInfoObject* obj, String& val)
+		{
+			obj->mTypeName = val;
+		}
+
+		bool& getIsValueType(ManagedSerializableTypeInfoObject* obj)
+		{
+			return obj->mValueType;
+		}
+
+		void setIsValueType(ManagedSerializableTypeInfoObject* obj, bool& val)
+		{
+			obj->mValueType = val;
+		}
+
+	public:
+		ManagedSerializableTypeInfoObjectRTTI()
+		{
+			addPlainField("mTypeName", 0, &ManagedSerializableTypeInfoObjectRTTI::getTypeName, &ManagedSerializableTypeInfoObjectRTTI::setTypeName);
+			addPlainField("mTypeNamespace", 1, &ManagedSerializableTypeInfoObjectRTTI::getTypeNamespace, &ManagedSerializableTypeInfoObjectRTTI::setTypeNamespace);
+			addPlainField("mValueType", 2, &ManagedSerializableTypeInfoObjectRTTI::getIsValueType, &ManagedSerializableTypeInfoObjectRTTI::setIsValueType);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableTypeInfoObject";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableTypeInfoObject;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableTypeInfoObject>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoArrayRTTI : public RTTIType<ManagedSerializableTypeInfoArray, ManagedSerializableTypeInfo, ManagedSerializableTypeInfoArrayRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoPtr getElementType(ManagedSerializableTypeInfoArray* obj)
+		{
+			return obj->mElementType;
+		}
+
+		void setElementType(ManagedSerializableTypeInfoArray* obj, ManagedSerializableTypeInfoPtr val)
+		{
+			obj->mElementType = val;
+		}
+
+		UINT32& getRank(ManagedSerializableTypeInfoArray* obj)
+		{
+			return obj->mRank;
+		}
+
+		void setRank(ManagedSerializableTypeInfoArray* obj, UINT32& val)
+		{
+			obj->mRank = val;
+		}
+
+	public:
+		ManagedSerializableTypeInfoArrayRTTI()
+		{
+			addReflectablePtrField("mElementType", 0, &ManagedSerializableTypeInfoArrayRTTI::getElementType, &ManagedSerializableTypeInfoArrayRTTI::setElementType);
+			addPlainField("mRank", 1, &ManagedSerializableTypeInfoArrayRTTI::getRank, &ManagedSerializableTypeInfoArrayRTTI::setRank);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableTypeInfoArray";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableTypeInfoArray;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableTypeInfoArray>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoListRTTI : public RTTIType<ManagedSerializableTypeInfoList, ManagedSerializableTypeInfo, ManagedSerializableTypeInfoListRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoPtr getElementType(ManagedSerializableTypeInfoList* obj)
+		{
+			return obj->mElementType;
+		}
+
+		void setElementType(ManagedSerializableTypeInfoList* obj, ManagedSerializableTypeInfoPtr val)
+		{
+			obj->mElementType = val;
+		}
+
+	public:
+		ManagedSerializableTypeInfoListRTTI()
+		{
+			addReflectablePtrField("mElementType", 0, &ManagedSerializableTypeInfoListRTTI::getElementType, &ManagedSerializableTypeInfoListRTTI::setElementType);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableTypeInfoList";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableTypeInfoList;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableTypeInfoList>();
+		}
+	};
+
+	class BS_SCR_BE_EXPORT ManagedSerializableTypeInfoDictionaryRTTI : public RTTIType<ManagedSerializableTypeInfoDictionary, ManagedSerializableTypeInfo, ManagedSerializableTypeInfoDictionaryRTTI>
+	{
+	private:
+		ManagedSerializableTypeInfoPtr getKeyType(ManagedSerializableTypeInfoDictionary* obj)
+		{
+			return obj->mKeyType;
+		}
+
+		void setKeyType(ManagedSerializableTypeInfoDictionary* obj, ManagedSerializableTypeInfoPtr val)
+		{
+			obj->mKeyType = val;
+		}
+
+		ManagedSerializableTypeInfoPtr getValueType(ManagedSerializableTypeInfoDictionary* obj)
+		{
+			return obj->mValueType;
+		}
+
+		void setValueType(ManagedSerializableTypeInfoDictionary* obj, ManagedSerializableTypeInfoPtr val)
+		{
+			obj->mValueType = val;
+		}
+
+	public:
+		ManagedSerializableTypeInfoDictionaryRTTI()
+		{
+			addReflectablePtrField("mKeyType", 0, &ManagedSerializableTypeInfoDictionaryRTTI::getKeyType, &ManagedSerializableTypeInfoDictionaryRTTI::setKeyType);
+			addReflectablePtrField("mValueType", 1, &ManagedSerializableTypeInfoDictionaryRTTI::getValueType, &ManagedSerializableTypeInfoDictionaryRTTI::setValueType);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableTypeInfoDictionary";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_SerializableTypeInfoDictionary;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return cm_shared_ptr<ManagedSerializableTypeInfoDictionary>();
+		}
+	};
+}

SBansheeEngine/Include/BsManagedSerializableObjectRTTI.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "CmRTTIType.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsManagedSerializableObject.h"
+#include "BsManagedSerializableField.h"
+#include "CmGameObjectManager.h"
+#include "BsMonoClass.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ManagedSerializableObjectRTTI : public RTTIType<ManagedSerializableObject, IReflectable, ManagedSerializableObjectRTTI>
+	{
+	private:
+		ManagedSerializableObjectInfoPtr getInfo(ManagedSerializableObject* obj)
+		{
+			return obj->mObjInfo;
+		}
+
+		void setInfo(ManagedSerializableObject* obj, ManagedSerializableObjectInfoPtr val)
+		{
+			obj->mObjInfo = val;
+		}
+
+		ManagedSerializableFieldDataEntryPtr getFieldEntry(ManagedSerializableObject* obj, UINT32 arrayIdx)
+		{
+			return obj->mFieldEntries[arrayIdx];
+		}
+
+		void setFieldsEntry(ManagedSerializableObject* obj, UINT32 arrayIdx, ManagedSerializableFieldDataEntryPtr val)
+		{
+			obj->mFieldEntries[arrayIdx] = val;
+		}
+
+		UINT32 getNumFieldEntries(ManagedSerializableObject* obj)
+		{
+			return (UINT32)obj->mFieldEntries.size();
+		}
+
+		void setNumFieldEntries(ManagedSerializableObject* obj, UINT32 numEntries)
+		{
+			obj->mFieldEntries.resize(numEntries);
+		}
+
+	public:
+		ManagedSerializableObjectRTTI()
+		{
+			addReflectablePtrField("mObjInfo", 0, &ManagedSerializableObjectRTTI::getInfo, &ManagedSerializableObjectRTTI::setInfo);
+			addReflectablePtrArrayField("mFieldEntries", 1, &ManagedSerializableObjectRTTI::getFieldEntry, &ManagedSerializableObjectRTTI::getNumFieldEntries, 
+				&ManagedSerializableObjectRTTI::setFieldsEntry, &ManagedSerializableObjectRTTI::setNumFieldEntries);
+		}
+
+		virtual void onSerializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableObject* serializableObject = static_cast<ManagedSerializableObject*>(obj);
+			serializableObject->serializeManagedInstance();
+		}
+
+		virtual void onDeserializationStarted(IReflectable* obj)
+		{
+			ManagedSerializableObject* serializableObject = static_cast<ManagedSerializableObject*>(obj);
+
+			// If we are deserializing a GameObject we need to defer deserializing actual field values
+			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
+			if(GameObjectManager::instance().isGameObjectDeserializationActive())
+				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
+			else
+				serializableObject->deserializeManagedInstance();
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "ScriptSerializableObject";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_ScriptSerializableObject;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return ManagedSerializableObject::createEmpty();
+		}
+	};
+}

SBansheeEngine/Include/BsRuntimeScriptObjects.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "BsScriptEnginePrerequisites.h"
-#include "BsScriptSerializableObjectInfo.h"
+#include "BsManagedSerializableObjectInfo.h"
 #include "CmModule.h"
 #include <mono/jit/jit.h>
 
@@ -14,7 +14,7 @@ namespace BansheeEngine
 		~RuntimeScriptObjects();
 
 		void refreshScriptObjects(const String& assemblyName);
-		bool getSerializableObjectInfo(const String& ns, const String& typeName, std::shared_ptr<ScriptSerializableObjectInfo>& outInfo);
+		bool getSerializableObjectInfo(const String& ns, const String& typeName, std::shared_ptr<ManagedSerializableObjectInfo>& outInfo);
 		bool hasSerializableObjectInfo(const String& ns, const String& typeName);
 
 		MonoClass* getSystemArrayClass() const { return mSystemArrayClass; }
@@ -25,7 +25,7 @@ namespace BansheeEngine
 		MonoClass* getTextureClass() const { return mTextureClass; }
 		MonoClass* getSpriteTextureClass() const { return mSpriteTextureClass; }
 	private:
-		UnorderedMap<String, std::shared_ptr<ScriptSerializableAssemblyInfo>>::type mAssemblyInfos;
+		UnorderedMap<String, std::shared_ptr<ManagedSerializableAssemblyInfo>>::type mAssemblyInfos;
 		bool mBaseTypesInitialized;
 
 		MonoClass* mSystemArrayClass;
@@ -38,7 +38,7 @@ namespace BansheeEngine
 		MonoClass* mTextureClass;
 		MonoClass* mSpriteTextureClass;
 
-		MonoClass* mSerializableObjectAttribute;
+		MonoClass* mSerializeObjectAttribute;
 		MonoClass* mDontSerializeFieldAttribute;
 		MonoClass* mSerializeFieldAttribute;
 		MonoClass* mHideInInspectorAttribute;
@@ -46,6 +46,6 @@ namespace BansheeEngine
 		void clearScriptObjects(const String& assemblyName);
 
 		void initializeBaseTypes();
-		ScriptSerializableTypeInfoPtr determineType(MonoClass* monoClass);
+		ManagedSerializableTypeInfoPtr determineType(MonoClass* monoClass);
 	};
 }

SBansheeEngine/Include/BsScriptEnginePrerequisites.h

@@ -35,22 +35,22 @@ namespace BansheeEngine
 	class ScriptSceneObject;
 	class ScriptComponent;
 	class ManagedComponent;
-	class ScriptSerializableFieldData;
-	class ScriptSerializableFieldKey;
-	class ScriptSerializableFieldDataEntry;
-	class ScriptSerializableTypeInfo;
-	class ScriptSerializableTypeInfoPrimitive;
-	class ScriptSerializableTypeInfoObject;
-	class ScriptSerializableTypeInfoArray;
-	class ScriptSerializableTypeInfoList;
-	class ScriptSerializableTypeInfoDictionary;
-	class ScriptSerializableObject;
-	class ScriptSerializableArray;
-	class ScriptSerializableList;
-	class ScriptSerializableDictionary;
-	class ScriptSerializableAssemblyInfo;
-	class ScriptSerializableObjectInfo;
-	class ScriptSerializableFieldInfo;
+	class ManagedSerializableFieldData;
+	class ManagedSerializableFieldKey;
+	class ManagedSerializableFieldDataEntry;
+	class ManagedSerializableTypeInfo;
+	class ManagedSerializableTypeInfoPrimitive;
+	class ManagedSerializableTypeInfoObject;
+	class ManagedSerializableTypeInfoArray;
+	class ManagedSerializableTypeInfoList;
+	class ManagedSerializableTypeInfoDictionary;
+	class ManagedSerializableObject;
+	class ManagedSerializableArray;
+	class ManagedSerializableList;
+	class ManagedSerializableDictionary;
+	class ManagedSerializableAssemblyInfo;
+	class ManagedSerializableObjectInfo;
+	class ManagedSerializableFieldInfo;
 
 	enum TypeID_BansheeScript
 	{
@@ -94,19 +94,19 @@ namespace BansheeEngine
 
 	static const char* BansheeEngineAssemblyName = "MBansheeEngine";
 
-	typedef std::shared_ptr<ScriptSerializableFieldData> ScriptSerializableFieldDataPtr;
-	typedef std::shared_ptr<ScriptSerializableFieldKey> ScriptSerializableFieldKeyPtr;
-	typedef std::shared_ptr<ScriptSerializableFieldDataEntry> ScriptSerializableFieldDataEntryPtr;
-	typedef std::shared_ptr<ScriptSerializableTypeInfo> ScriptSerializableTypeInfoPtr;
-	typedef std::shared_ptr<ScriptSerializableTypeInfoObject> ScriptSerializableTypeInfoObjectPtr;
-	typedef std::shared_ptr<ScriptSerializableObject> ScriptSerializableObjectPtr;
-	typedef std::shared_ptr<ScriptSerializableArray> ScriptSerializableArrayPtr;
-	typedef std::shared_ptr<ScriptSerializableList> ScriptSerializableListPtr;
-	typedef std::shared_ptr<ScriptSerializableDictionary> ScriptSerializableDictionaryPtr;
-	typedef std::shared_ptr<ScriptSerializableAssemblyInfo> ScriptSerializableAssemblyInfoPtr;
-	typedef std::shared_ptr<ScriptSerializableObjectInfo> ScriptSerializableObjectInfoPtr;
-	typedef std::shared_ptr<ScriptSerializableFieldInfo> ScriptSerializableFieldInfoPtr;
-	typedef std::shared_ptr<ScriptSerializableTypeInfoArray> ScriptSerializableTypeInfoArrayPtr;
-	typedef std::shared_ptr<ScriptSerializableTypeInfoList> ScriptSerializableTypeInfoListPtr;
-	typedef std::shared_ptr<ScriptSerializableTypeInfoDictionary> ScriptSerializableTypeInfoDictionaryPtr;
+	typedef std::shared_ptr<ManagedSerializableFieldData> ManagedSerializableFieldDataPtr;
+	typedef std::shared_ptr<ManagedSerializableFieldKey> ManagedSerializableFieldKeyPtr;
+	typedef std::shared_ptr<ManagedSerializableFieldDataEntry> ManagedSerializableFieldDataEntryPtr;
+	typedef std::shared_ptr<ManagedSerializableTypeInfo> ManagedSerializableTypeInfoPtr;
+	typedef std::shared_ptr<ManagedSerializableTypeInfoObject> ScriptSerializableTypeInfoObjectPtr;
+	typedef std::shared_ptr<ManagedSerializableObject> ManagedSerializableObjectPtr;
+	typedef std::shared_ptr<ManagedSerializableArray> ManagedSerializableArrayPtr;
+	typedef std::shared_ptr<ManagedSerializableList> ManagedSerializableListPtr;
+	typedef std::shared_ptr<ManagedSerializableDictionary> ManagedSerializableDictionaryPtr;
+	typedef std::shared_ptr<ManagedSerializableAssemblyInfo> ManagedSerializableAssemblyInfoPtr;
+	typedef std::shared_ptr<ManagedSerializableObjectInfo> ManagedSerializableObjectInfoPtr;
+	typedef std::shared_ptr<ManagedSerializableFieldInfo> ManagedSerializableFieldInfoPtr;
+	typedef std::shared_ptr<ManagedSerializableTypeInfoArray> ManagedSerializableTypeInfoArrayPtr;
+	typedef std::shared_ptr<ManagedSerializableTypeInfoList> ManagedSerializableTypeInfoListPtr;
+	typedef std::shared_ptr<ManagedSerializableTypeInfoDictionary> ManagedSerializableTypeInfoDictionaryPtr;
 }

SBansheeEngine/Include/BsScriptSerializableArrayRTTI.h

@@ -1,121 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmRTTIType.h"
-#include "CmGameObjectManager.h"
-#include "BsScriptSerializableArray.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsMonoManager.h"
-#include "BsMonoClass.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableArrayRTTI : public RTTIType<ScriptSerializableArray, IReflectable, ScriptSerializableArrayRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoArrayPtr getTypeInfo(ScriptSerializableArray* obj)
-		{
-			return obj->mArrayTypeInfo;
-		}
-
-		void setTypeInfo(ScriptSerializableArray* obj, ScriptSerializableTypeInfoArrayPtr val)
-		{
-			obj->mArrayTypeInfo = val;
-		}
-
-		UINT32& getElementSize(ScriptSerializableArray* obj)
-		{
-			return (UINT32)obj->mElemSize;
-		}
-
-		void setElementSize(ScriptSerializableArray* obj, UINT32& numElements)
-		{
-			obj->mElemSize = numElements;
-		}
-
-		UINT32& getNumElements(ScriptSerializableArray* obj, UINT32 arrayIdx)
-		{
-			return (UINT32)obj->mNumElements[arrayIdx];
-		}
-
-		void setNumElements(ScriptSerializableArray* obj, UINT32 arrayIdx, UINT32& numElements)
-		{
-			obj->mNumElements[arrayIdx] = numElements;
-		}
-
-		UINT32 getNumElementsNumEntries(ScriptSerializableArray* obj)
-		{
-			return (UINT32)obj->mNumElements.size();
-		}
-
-		void setNumElementsNumEntries(ScriptSerializableArray* obj, UINT32 numEntries)
-		{
-			obj->mNumElements.resize(numEntries);
-		}
-
-		ScriptSerializableFieldDataPtr getArrayEntry(ScriptSerializableArray* obj, UINT32 arrayIdx)
-		{
-			return obj->mArrayEntries[arrayIdx];
-		}
-
-		void setArrayEntry(ScriptSerializableArray* obj, UINT32 arrayIdx, ScriptSerializableFieldDataPtr val)
-		{
-			obj->mArrayEntries[arrayIdx] = val;
-		}
-
-		UINT32 getNumArrayEntries(ScriptSerializableArray* obj)
-		{
-			return (UINT32)obj->mArrayEntries.size();
-		}
-
-		void setNumArrayEntries(ScriptSerializableArray* obj, UINT32 numEntries)
-		{
-			obj->mArrayEntries.resize(numEntries);
-		}
-
-	public:
-		ScriptSerializableArrayRTTI()
-		{
-			addReflectablePtrField("mArrayTypeInfo", 0, &ScriptSerializableArrayRTTI::getTypeInfo, &ScriptSerializableArrayRTTI::setTypeInfo);
-			addPlainField("mElementSize", 1, &ScriptSerializableArrayRTTI::getElementSize, &ScriptSerializableArrayRTTI::setElementSize);
-			addPlainArrayField("mNumElements", 2, &ScriptSerializableArrayRTTI::getNumElements, &ScriptSerializableArrayRTTI::getNumElementsNumEntries, 
-				&ScriptSerializableArrayRTTI::setNumElements, &ScriptSerializableArrayRTTI::setNumElementsNumEntries);
-			addReflectablePtrArrayField("mArrayEntries", 3, &ScriptSerializableArrayRTTI::getArrayEntry, &ScriptSerializableArrayRTTI::getNumArrayEntries, 
-				&ScriptSerializableArrayRTTI::setArrayEntry, &ScriptSerializableArrayRTTI::setNumArrayEntries);
-		}
-
-		virtual void onSerializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableArray* serializableObject = static_cast<ScriptSerializableArray*>(obj);
-			serializableObject->serializeManagedInstance();
-		}
-
-		virtual void onDeserializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableArray* serializableObject = static_cast<ScriptSerializableArray*>(obj);
-
-			// If we are deserializing a GameObject we need to defer deserializing actual field values
-			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
-			if(GameObjectManager::instance().isGameObjectDeserializationActive())
-				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
-			else
-				serializableObject->deserializeManagedInstance();
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableArray";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_ScriptSerializableArray;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return ScriptSerializableArray::createEmpty();
-		}
-	};
-}

SBansheeEngine/Include/BsScriptSerializableDictionaryRTTI.h

@@ -1,73 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmRTTIType.h"
-#include "CmGameObjectManager.h"
-#include "BsScriptSerializableDictionary.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsMonoManager.h"
-#include "BsMonoClass.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableDictionaryRTTI : public RTTIType<ScriptSerializableDictionary, IReflectable, ScriptSerializableDictionaryRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoDictionaryPtr getTypeInfo(ScriptSerializableDictionary* obj) { return obj->mDictionaryTypeInfo; }
-		void setTypeInfo(ScriptSerializableDictionary* obj, ScriptSerializableTypeInfoDictionaryPtr val) { obj->mDictionaryTypeInfo = val; }
-
-		ScriptSerializableFieldDataPtr getKeyEntry(ScriptSerializableDictionary* obj, UINT32 arrayIdx) { return obj->mKeyEntries[arrayIdx]; }
-		void setKeyEntry(ScriptSerializableDictionary* obj, UINT32 arrayIdx, ScriptSerializableFieldDataPtr val) { obj->mKeyEntries[arrayIdx] = val; }
-		UINT32 getNumKeyEntries(ScriptSerializableDictionary* obj) { return (UINT32)obj->mKeyEntries.size(); }
-		void setNumKeyEntries(ScriptSerializableDictionary* obj, UINT32 numEntries) { obj->mKeyEntries.resize(numEntries); }
-
-		ScriptSerializableFieldDataPtr getValueEntry(ScriptSerializableDictionary* obj, UINT32 arrayIdx) { return obj->mValueEntries[arrayIdx]; }
-		void setValueEntry(ScriptSerializableDictionary* obj, UINT32 arrayIdx, ScriptSerializableFieldDataPtr val) { obj->mValueEntries[arrayIdx] = val; }
-		UINT32 getNumValueEntries(ScriptSerializableDictionary* obj) { return (UINT32)obj->mValueEntries.size(); }
-		void setNumValueEntries(ScriptSerializableDictionary* obj, UINT32 numEntries) { obj->mValueEntries.resize(numEntries); }
-
-	public:
-		ScriptSerializableDictionaryRTTI()
-		{
-			addReflectablePtrField("mListTypeInfo", 0, &ScriptSerializableDictionaryRTTI::getTypeInfo, &ScriptSerializableDictionaryRTTI::setTypeInfo);
-			addReflectablePtrArrayField("mKeyEntries", 1, &ScriptSerializableDictionaryRTTI::getKeyEntry, &ScriptSerializableDictionaryRTTI::getNumKeyEntries, 
-				&ScriptSerializableDictionaryRTTI::setKeyEntry, &ScriptSerializableDictionaryRTTI::setNumKeyEntries);
-			addReflectablePtrArrayField("mValueEntries", 2, &ScriptSerializableDictionaryRTTI::getValueEntry, &ScriptSerializableDictionaryRTTI::getNumValueEntries, 
-				&ScriptSerializableDictionaryRTTI::setValueEntry, &ScriptSerializableDictionaryRTTI::setNumValueEntries);
-		}
-
-		virtual void onSerializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableDictionary* serializableObject = static_cast<ScriptSerializableDictionary*>(obj);
-			serializableObject->serializeManagedInstance();
-		}
-
-		virtual void onDeserializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableDictionary* serializableObject = static_cast<ScriptSerializableDictionary*>(obj);
-
-			// If we are deserializing a GameObject we need to defer deserializing actual field values
-			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
-			if(GameObjectManager::instance().isGameObjectDeserializationActive())
-				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
-			else
-				serializableObject->deserializeManagedInstance();
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableDictionary";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_ScriptSerializableDictionary;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return ScriptSerializableDictionary::createEmpty();
-		}
-	};
-}

SBansheeEngine/Include/BsScriptSerializableFieldRTTI.h

@@ -1,653 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmRTTIType.h"
-#include "BsScriptSerializableField.h"
-#include "CmException.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldKeyRTTI : public RTTIType<ScriptSerializableFieldKey, IReflectable, ScriptSerializableFieldKeyRTTI>
-	{
-	private:
-		UINT16& getTypeId(ScriptSerializableFieldKey* obj) { return obj->mTypeId; }
-		void setTypeId(ScriptSerializableFieldKey* obj, UINT16& val) { obj->mTypeId = val; }
-
-		UINT16& getFieldId(ScriptSerializableFieldKey* obj) { return obj->mFieldId; }
-		void setFieldId(ScriptSerializableFieldKey* obj, UINT16& val) { obj->mFieldId = val; }
-
-	public:
-		ScriptSerializableFieldKeyRTTI()
-		{
-			addPlainField("mTypeId", 0, &ScriptSerializableFieldKeyRTTI::getTypeId, &ScriptSerializableFieldKeyRTTI::setTypeId);
-			addPlainField("mFieldId", 1, &ScriptSerializableFieldKeyRTTI::getFieldId, &ScriptSerializableFieldKeyRTTI::setFieldId);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldKey";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldKey;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldKey>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataRTTI : public RTTIType<ScriptSerializableFieldData, IReflectable, ScriptSerializableFieldDataRTTI>
-	{
-	private:
-
-	public:
-		ScriptSerializableFieldDataRTTI()
-		{
-
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldData";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldData;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			CM_EXCEPT(InvalidStateException, "Cannot instantiate an abstract class.");
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataEntryRTTI : public RTTIType<ScriptSerializableFieldDataEntry, IReflectable, ScriptSerializableFieldDataEntryRTTI>
-	{
-	private:
-		ScriptSerializableFieldKeyPtr getKey(ScriptSerializableFieldDataEntry* obj)	{ return obj->mKey; }
-		void setKey(ScriptSerializableFieldDataEntry* obj, ScriptSerializableFieldKeyPtr val) { obj->mKey = val; }
-
-		ScriptSerializableFieldDataPtr getValue(ScriptSerializableFieldDataEntry* obj) { return obj->mValue; }
-		void setValue(ScriptSerializableFieldDataEntry* obj, ScriptSerializableFieldDataPtr val) { obj->mValue = val; }
-
-	public:
-		ScriptSerializableFieldDataEntryRTTI()
-		{
-			addReflectablePtrField("mKey", 0, &ScriptSerializableFieldDataEntryRTTI::getKey, &ScriptSerializableFieldDataEntryRTTI::setKey);
-			addReflectablePtrField("mValue", 1, &ScriptSerializableFieldDataEntryRTTI::getValue, &ScriptSerializableFieldDataEntryRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataEntry";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataEntry;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataEntry>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataBoolRTTI : public RTTIType<ScriptSerializableFieldDataBool, ScriptSerializableFieldData, ScriptSerializableFieldDataBoolRTTI>
-	{
-	private:
-		bool& getValue(ScriptSerializableFieldDataBool* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataBool* obj, bool& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataBoolRTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataBoolRTTI::getValue, &ScriptSerializableFieldDataBoolRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataBool";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataBool;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataBool>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataCharRTTI : public RTTIType<ScriptSerializableFieldDataChar, ScriptSerializableFieldData, ScriptSerializableFieldDataCharRTTI>
-	{
-	private:
-		wchar_t& getValue(ScriptSerializableFieldDataChar* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataChar* obj, wchar_t& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataCharRTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataCharRTTI::getValue, &ScriptSerializableFieldDataCharRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataChar";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataChar;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataBool>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI8RTTI : public RTTIType<ScriptSerializableFieldDataI8, ScriptSerializableFieldData, ScriptSerializableFieldDataI8RTTI>
-	{
-	private:
-		INT8& getValue(ScriptSerializableFieldDataI8* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataI8* obj, INT8& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataI8RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataI8RTTI::getValue, &ScriptSerializableFieldDataI8RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataI8";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataI8;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataI8>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU8RTTI : public RTTIType<ScriptSerializableFieldDataU8, ScriptSerializableFieldData, ScriptSerializableFieldDataU8RTTI>
-	{
-	private:
-		UINT8& getValue(ScriptSerializableFieldDataU8* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataU8* obj, UINT8& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataU8RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataU8RTTI::getValue, &ScriptSerializableFieldDataU8RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataU8";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataU8;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataU8>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI16RTTI : public RTTIType<ScriptSerializableFieldDataI16, ScriptSerializableFieldData, ScriptSerializableFieldDataI16RTTI>
-	{
-	private:
-		INT16& getValue(ScriptSerializableFieldDataI16* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataI16* obj, INT16& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataI16RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataI16RTTI::getValue, &ScriptSerializableFieldDataI16RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataI16";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataI16;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataI16>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU16RTTI : public RTTIType<ScriptSerializableFieldDataU16, ScriptSerializableFieldData, ScriptSerializableFieldDataU16RTTI>
-	{
-	private:
-		UINT16& getValue(ScriptSerializableFieldDataU16* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataU16* obj, UINT16& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataU16RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataU16RTTI::getValue, &ScriptSerializableFieldDataU16RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataU16";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataU16;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataU16>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI32RTTI : public RTTIType<ScriptSerializableFieldDataI32, ScriptSerializableFieldData, ScriptSerializableFieldDataI32RTTI>
-	{
-	private:
-		INT32& getValue(ScriptSerializableFieldDataI32* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataI32* obj, INT32& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataI32RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataI32RTTI::getValue, &ScriptSerializableFieldDataI32RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataI32";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataI32;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataI32>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU32RTTI : public RTTIType<ScriptSerializableFieldDataU32, ScriptSerializableFieldData, ScriptSerializableFieldDataU32RTTI>
-	{
-	private:
-		UINT32& getValue(ScriptSerializableFieldDataU32* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataU32* obj, UINT32& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataU32RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataU32RTTI::getValue, &ScriptSerializableFieldDataU32RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataU32";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataU32;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataU32>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataI64RTTI : public RTTIType<ScriptSerializableFieldDataI64, ScriptSerializableFieldData, ScriptSerializableFieldDataI64RTTI>
-	{
-	private:
-		INT64& getValue(ScriptSerializableFieldDataI64* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataI64* obj, INT64& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataI64RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataI64RTTI::getValue, &ScriptSerializableFieldDataI64RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataI64";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataI64;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataI64>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataU64RTTI : public RTTIType<ScriptSerializableFieldDataU64, ScriptSerializableFieldData, ScriptSerializableFieldDataU64RTTI>
-	{
-	private:
-		UINT64& getValue(ScriptSerializableFieldDataU64* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataU64* obj, UINT64& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataU64RTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataU64RTTI::getValue, &ScriptSerializableFieldDataU64RTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataU64";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataU64;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataU64>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataFloatRTTI : public RTTIType<ScriptSerializableFieldDataFloat, ScriptSerializableFieldData, ScriptSerializableFieldDataFloatRTTI>
-	{
-	private:
-		float& getValue(ScriptSerializableFieldDataFloat* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataFloat* obj, float& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataFloatRTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataFloatRTTI::getValue, &ScriptSerializableFieldDataFloatRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataFloat";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataFloat;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataFloat>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataDoubleRTTI : public RTTIType<ScriptSerializableFieldDataDouble, ScriptSerializableFieldData, ScriptSerializableFieldDataDoubleRTTI>
-	{
-	private:
-		double& getValue(ScriptSerializableFieldDataDouble* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataDouble* obj, double& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataDoubleRTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataDoubleRTTI::getValue, &ScriptSerializableFieldDataDoubleRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataDouble";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataDouble;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataDouble>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataStringRTTI : public RTTIType<ScriptSerializableFieldDataString, ScriptSerializableFieldData, ScriptSerializableFieldDataStringRTTI>
-	{
-	private:
-		WString& getValue(ScriptSerializableFieldDataString* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataString* obj, WString& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataStringRTTI()
-		{
-			addPlainField("mValue", 0, &ScriptSerializableFieldDataStringRTTI::getValue, &ScriptSerializableFieldDataStringRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataString";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataString;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataString>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataResourceRefRTTI : public RTTIType<ScriptSerializableFieldDataResourceRef, ScriptSerializableFieldData, ScriptSerializableFieldDataResourceRefRTTI>
-	{
-	private:
-		HResource& getValue(ScriptSerializableFieldDataResourceRef* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataResourceRef* obj, HResource& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataResourceRefRTTI()
-		{
-			addReflectableField("mValue", 0, &ScriptSerializableFieldDataResourceRefRTTI::getValue, &ScriptSerializableFieldDataResourceRefRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataResourceRef";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataResourceRef;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataResourceRef>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataGameObjectRefRTTI : public RTTIType<ScriptSerializableFieldDataGameObjectRef, ScriptSerializableFieldData, ScriptSerializableFieldDataGameObjectRefRTTI>
-	{
-	private:
-		HGameObject& getValue(ScriptSerializableFieldDataGameObjectRef* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataGameObjectRef* obj, HGameObject& val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataGameObjectRefRTTI()
-		{
-			addReflectableField("mValue", 0, &ScriptSerializableFieldDataGameObjectRefRTTI::getValue, &ScriptSerializableFieldDataGameObjectRefRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataGameObjectRef";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataGameObjectRef;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataGameObjectRef>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataObjectRTTI : public RTTIType<ScriptSerializableFieldDataObject, ScriptSerializableFieldData, ScriptSerializableFieldDataObjectRTTI>
-	{
-	private:
-		ScriptSerializableObjectPtr getValue(ScriptSerializableFieldDataObject* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataObject* obj, ScriptSerializableObjectPtr val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataObjectRTTI()
-		{
-			addReflectablePtrField("mValue", 0, &ScriptSerializableFieldDataObjectRTTI::getValue, &ScriptSerializableFieldDataObjectRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataObject";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataObject;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataObject>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataArrayRTTI : public RTTIType<ScriptSerializableFieldDataArray, ScriptSerializableFieldData, ScriptSerializableFieldDataArrayRTTI>
-	{
-	private:
-		ScriptSerializableArrayPtr getValue(ScriptSerializableFieldDataArray* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataArray* obj, ScriptSerializableArrayPtr val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataArrayRTTI()
-		{
-			addReflectablePtrField("mValue", 0, &ScriptSerializableFieldDataArrayRTTI::getValue, &ScriptSerializableFieldDataArrayRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataArray";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataArray;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataArray>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataListRTTI : public RTTIType<ScriptSerializableFieldDataList, ScriptSerializableFieldData, ScriptSerializableFieldDataListRTTI>
-	{
-	private:
-		ScriptSerializableListPtr getValue(ScriptSerializableFieldDataList* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataList* obj, ScriptSerializableListPtr val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataListRTTI()
-		{
-			addReflectablePtrField("mValue", 0, &ScriptSerializableFieldDataListRTTI::getValue, &ScriptSerializableFieldDataListRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataList";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataList;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataList>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldDataDictionaryRTTI : public RTTIType<ScriptSerializableFieldDataDictionary, ScriptSerializableFieldData, ScriptSerializableFieldDataDictionaryRTTI>
-	{
-	private:
-		ScriptSerializableDictionaryPtr getValue(ScriptSerializableFieldDataDictionary* obj) { return obj->value; }
-		void setValue(ScriptSerializableFieldDataDictionary* obj, ScriptSerializableDictionaryPtr val) { obj->value = val; }
-
-	public:
-		ScriptSerializableFieldDataDictionaryRTTI()
-		{
-			addReflectablePtrField("mValue", 0, &ScriptSerializableFieldDataDictionaryRTTI::getValue, &ScriptSerializableFieldDataDictionaryRTTI::setValue);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "SerializableFieldDataDictionary";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldDataDictionary;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableFieldDataDictionary>();
-		}
-	};
-}

SBansheeEngine/Include/BsScriptSerializableListRTTI.h

@@ -1,99 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmRTTIType.h"
-#include "CmGameObjectManager.h"
-#include "BsScriptSerializableList.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsMonoManager.h"
-#include "BsMonoClass.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableListRTTI : public RTTIType<ScriptSerializableList, IReflectable, ScriptSerializableListRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoListPtr getTypeInfo(ScriptSerializableList* obj)
-		{
-			return obj->mListTypeInfo;
-		}
-
-		void setTypeInfo(ScriptSerializableList* obj, ScriptSerializableTypeInfoListPtr val)
-		{
-			obj->mListTypeInfo = val;
-		}
-
-		UINT32& getNumElements(ScriptSerializableList* obj)
-		{
-			return (UINT32)obj->mNumElements;
-		}
-
-		void setNumElements(ScriptSerializableList* obj, UINT32& numElements)
-		{
-			obj->mNumElements = numElements;
-		}
-
-		ScriptSerializableFieldDataPtr getListEntry(ScriptSerializableList* obj, UINT32 arrayIdx)
-		{
-			return obj->mListEntries[arrayIdx];
-		}
-
-		void setListEntry(ScriptSerializableList* obj, UINT32 arrayIdx, ScriptSerializableFieldDataPtr val)
-		{
-			obj->mListEntries[arrayIdx] = val;
-		}
-
-		UINT32 getNumListEntries(ScriptSerializableList* obj)
-		{
-			return (UINT32)obj->mListEntries.size();
-		}
-
-		void setNumListEntries(ScriptSerializableList* obj, UINT32 numEntries)
-		{
-			obj->mListEntries.resize(numEntries);
-		}
-
-	public:
-		ScriptSerializableListRTTI()
-		{
-			addReflectablePtrField("mListTypeInfo", 0, &ScriptSerializableListRTTI::getTypeInfo, &ScriptSerializableListRTTI::setTypeInfo);
-			addPlainField("mNumElements", 1, &ScriptSerializableListRTTI::getNumElements, &ScriptSerializableListRTTI::setNumElements);
-			addReflectablePtrArrayField("mListEntries", 2, &ScriptSerializableListRTTI::getListEntry, &ScriptSerializableListRTTI::getNumListEntries, 
-				&ScriptSerializableListRTTI::setListEntry, &ScriptSerializableListRTTI::setNumListEntries);
-		}
-
-		virtual void onSerializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableList* serializableObject = static_cast<ScriptSerializableList*>(obj);
-			serializableObject->serializeManagedInstance();
-		}
-
-		virtual void onDeserializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableList* serializableObject = static_cast<ScriptSerializableList*>(obj);
-
-			// If we are deserializing a GameObject we need to defer deserializing actual field values
-			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
-			if(GameObjectManager::instance().isGameObjectDeserializationActive())
-				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
-			else
-				serializableObject->deserializeManagedInstance();
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableList";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_ScriptSerializableList;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return ScriptSerializableList::createEmpty();
-		}
-	};
-}

SBansheeEngine/Include/BsScriptSerializableObjectInfoRTTI.h

@@ -1,465 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmRTTIType.h"
-#include "BsScriptSerializableObjectInfo.h"
-#include "CmException.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableAssemblyInfoRTTI : public RTTIType<ScriptSerializableAssemblyInfo, IReflectable, ScriptSerializableAssemblyInfoRTTI>
-	{
-	private:
-		String& getName(ScriptSerializableAssemblyInfo* obj)
-		{
-			return obj->mName;
-		}
-
-		void setName(ScriptSerializableAssemblyInfo* obj, String& val)
-		{
-			obj->mName = val;
-		}
-
-		ScriptSerializableObjectInfoPtr getSerializableObjectInfo(ScriptSerializableAssemblyInfo* obj, UINT32 idx) 
-		{ 
-			auto iter = obj->mObjectInfos.begin();
-			for(UINT32 i = 0; i < idx; i++)
-				iter++;
-
-			return iter->second;
-		}
-
-		void setSerializableObjectInfo(ScriptSerializableAssemblyInfo* obj, UINT32 idx, ScriptSerializableObjectInfoPtr val) 
-		{ 
-			obj->mTypeNameToId[val->getFullTypeName()] = val->mTypeId;
-			obj->mObjectInfos[val->mTypeId] = val;
-		}
-		
-		UINT32 getSerializableObjectInfoArraySize(ScriptSerializableAssemblyInfo* obj) { return (UINT32)obj->mObjectInfos.size(); }
-		void setSerializableObjectInfoArraySize(ScriptSerializableAssemblyInfo* obj, UINT32 size) {  }
-
-	public:
-		ScriptSerializableAssemblyInfoRTTI()
-		{
-			addPlainField("mName", 0, &ScriptSerializableAssemblyInfoRTTI::getName, &ScriptSerializableAssemblyInfoRTTI::setName);
-			addReflectablePtrArrayField("mObjectInfos", 1, &ScriptSerializableAssemblyInfoRTTI::getSerializableObjectInfo, 
-				&ScriptSerializableAssemblyInfoRTTI::getSerializableObjectInfoArraySize, &ScriptSerializableAssemblyInfoRTTI::setSerializableObjectInfo, 
-				&ScriptSerializableAssemblyInfoRTTI::setSerializableObjectInfoArraySize);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableAssemblyInfo";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableAssemblyInfo;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableAssemblyInfo>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableObjectInfoRTTI : public RTTIType<ScriptSerializableObjectInfo, IReflectable, ScriptSerializableObjectInfoRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoObjectPtr getTypeInfo(ScriptSerializableObjectInfo* obj)
-		{
-			return obj->mTypeInfo;
-		}
-
-		void setTypeInfo(ScriptSerializableObjectInfo* obj, ScriptSerializableTypeInfoObjectPtr val)
-		{
-			obj->mTypeInfo = val;
-		}
-
-		UINT32& getTypeId(ScriptSerializableObjectInfo* obj)
-		{
-			return obj->mTypeId;
-		}
-
-		void setTypeId(ScriptSerializableObjectInfo* obj, UINT32& val)
-		{
-			obj->mTypeId = val;
-		}
-
-		ScriptSerializableObjectInfoPtr getBaseClass(ScriptSerializableObjectInfo* obj)
-		{
-			return obj->mBaseClass;
-		}
-
-		void setBaseClass(ScriptSerializableObjectInfo* obj, ScriptSerializableObjectInfoPtr val)
-		{
-			obj->mBaseClass = val;
-		}
-
-		ScriptSerializableFieldInfoPtr getSerializableFieldInfo(ScriptSerializableObjectInfo* obj, UINT32 idx) 
-		{ 
-			auto iter = obj->mFields.begin();
-			for(UINT32 i = 0; i < idx; i++)
-				iter++;
-
-			return iter->second;
-		}
-
-		void setSerializableFieldInfo(ScriptSerializableObjectInfo* obj, UINT32 idx, ScriptSerializableFieldInfoPtr val) 
-		{ 
-			obj->mFieldNameToId[val->mName] = val->mFieldId;
-			obj->mFields[val->mFieldId] = val;
-		}
-
-		UINT32 getSerializableFieldInfoArraySize(ScriptSerializableObjectInfo* obj) { return (UINT32)obj->mFields.size(); }
-		void setSerializableFieldInfoArraySize(ScriptSerializableObjectInfo* obj, UINT32 size) {  }
-
-	public:
-		ScriptSerializableObjectInfoRTTI()
-		{
-			addReflectablePtrField("mTypeInfo", 0, &ScriptSerializableObjectInfoRTTI::getTypeInfo, &ScriptSerializableObjectInfoRTTI::setTypeInfo);
-			addPlainField("mTypeId", 1, &ScriptSerializableObjectInfoRTTI::getTypeId, &ScriptSerializableObjectInfoRTTI::setTypeId);
-			addReflectablePtrField("mBaseClass", 2, &ScriptSerializableObjectInfoRTTI::getBaseClass, &ScriptSerializableObjectInfoRTTI::setBaseClass);
-
-			addReflectablePtrArrayField("mFields", 3, &ScriptSerializableObjectInfoRTTI::getSerializableFieldInfo, 
-				&ScriptSerializableObjectInfoRTTI::getSerializableFieldInfoArraySize, &ScriptSerializableObjectInfoRTTI::setSerializableFieldInfo, 
-				&ScriptSerializableObjectInfoRTTI::setSerializableFieldInfoArraySize);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableObjectInfo";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableObjectInfo;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableObjectInfo>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableFieldInfoRTTI : public RTTIType<ScriptSerializableFieldInfo, IReflectable, ScriptSerializableFieldInfoRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoPtr getTypeInfo(ScriptSerializableFieldInfo* obj)
-		{
-			return obj->mTypeInfo;
-		}
-
-		void setTypeInfo(ScriptSerializableFieldInfo* obj, ScriptSerializableTypeInfoPtr val)
-		{
-			obj->mTypeInfo = val;
-		}
-
-		String& getName(ScriptSerializableFieldInfo* obj)
-		{
-			return obj->mName;
-		}
-
-		void setName(ScriptSerializableFieldInfo* obj, String& val)
-		{
-			obj->mName = val;
-		}
-
-		UINT32& getFieldId(ScriptSerializableFieldInfo* obj)
-		{
-			return obj->mFieldId;
-		}
-
-		void setFieldId(ScriptSerializableFieldInfo* obj, UINT32& val)
-		{
-			obj->mFieldId = val;
-		}
-
-		UINT32& getFlags(ScriptSerializableFieldInfo* obj)
-		{
-			return (UINT32&)obj->mFlags;
-		}
-
-		void setFlags(ScriptSerializableFieldInfo* obj, UINT32& val)
-		{
-			obj->mFlags = (ScriptFieldFlags)val;
-		}
-
-	public:
-		ScriptSerializableFieldInfoRTTI()
-		{
-			addPlainField("mName", 0, &ScriptSerializableFieldInfoRTTI::getName, &ScriptSerializableFieldInfoRTTI::setName);
-			addReflectablePtrField("mTypeInfo", 1, &ScriptSerializableFieldInfoRTTI::getTypeInfo, &ScriptSerializableFieldInfoRTTI::setTypeInfo);
-			addPlainField("mFieldId", 2, &ScriptSerializableFieldInfoRTTI::getFieldId, &ScriptSerializableFieldInfoRTTI::setFieldId);
-			addPlainField("mFlags", 3, &ScriptSerializableFieldInfoRTTI::getFlags, &ScriptSerializableFieldInfoRTTI::setFlags);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableFieldInfo";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableFieldInfo;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{return cm_shared_ptr<ScriptSerializableFieldInfo>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoRTTI : public RTTIType<ScriptSerializableTypeInfo, IReflectable, ScriptSerializableTypeInfoRTTI>
-	{
-	private:
-
-	public:
-		ScriptSerializableTypeInfoRTTI()
-		{
-
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableTypeInfo";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableTypeInfo;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			CM_EXCEPT(InvalidStateException, "Cannot instantiate an abstract class");
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoPrimitiveRTTI : public RTTIType<ScriptSerializableTypeInfoPrimitive, ScriptSerializableTypeInfo, ScriptSerializableTypeInfoPrimitiveRTTI>
-	{
-	private:
-		ScriptPrimitiveType& getType(ScriptSerializableTypeInfoPrimitive* obj)
-		{
-			return obj->mType;
-		}
-
-		void setType(ScriptSerializableTypeInfoPrimitive* obj, ScriptPrimitiveType& val)
-		{
-			obj->mType = val;
-		}
-
-	public:
-		ScriptSerializableTypeInfoPrimitiveRTTI()
-		{
-			addPlainField("mType", 0, &ScriptSerializableTypeInfoPrimitiveRTTI::getType, &ScriptSerializableTypeInfoPrimitiveRTTI::setType);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableTypeInfoPrimitive";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableTypeInfoPrimitive;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoObjectRTTI : public RTTIType<ScriptSerializableTypeInfoObject, ScriptSerializableTypeInfo, ScriptSerializableTypeInfoObjectRTTI>
-	{
-	private:
-		String& getTypeNamespace(ScriptSerializableTypeInfoObject* obj)
-		{
-			return obj->mTypeNamespace;
-		}
-
-		void setTypeNamespace(ScriptSerializableTypeInfoObject* obj, String& val)
-		{
-			obj->mTypeNamespace = val;
-		}
-
-		String& getTypeName(ScriptSerializableTypeInfoObject* obj)
-		{
-			return obj->mTypeName;
-		}
-
-		void setTypeName(ScriptSerializableTypeInfoObject* obj, String& val)
-		{
-			obj->mTypeName = val;
-		}
-
-		bool& getIsValueType(ScriptSerializableTypeInfoObject* obj)
-		{
-			return obj->mValueType;
-		}
-
-		void setIsValueType(ScriptSerializableTypeInfoObject* obj, bool& val)
-		{
-			obj->mValueType = val;
-		}
-
-	public:
-		ScriptSerializableTypeInfoObjectRTTI()
-		{
-			addPlainField("mTypeName", 0, &ScriptSerializableTypeInfoObjectRTTI::getTypeName, &ScriptSerializableTypeInfoObjectRTTI::setTypeName);
-			addPlainField("mTypeNamespace", 1, &ScriptSerializableTypeInfoObjectRTTI::getTypeNamespace, &ScriptSerializableTypeInfoObjectRTTI::setTypeNamespace);
-			addPlainField("mValueType", 2, &ScriptSerializableTypeInfoObjectRTTI::getIsValueType, &ScriptSerializableTypeInfoObjectRTTI::setIsValueType);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableTypeInfoObject";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableTypeInfoObject;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableTypeInfoObject>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoArrayRTTI : public RTTIType<ScriptSerializableTypeInfoArray, ScriptSerializableTypeInfo, ScriptSerializableTypeInfoArrayRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoPtr getElementType(ScriptSerializableTypeInfoArray* obj)
-		{
-			return obj->mElementType;
-		}
-
-		void setElementType(ScriptSerializableTypeInfoArray* obj, ScriptSerializableTypeInfoPtr val)
-		{
-			obj->mElementType = val;
-		}
-
-		UINT32& getRank(ScriptSerializableTypeInfoArray* obj)
-		{
-			return obj->mRank;
-		}
-
-		void setRank(ScriptSerializableTypeInfoArray* obj, UINT32& val)
-		{
-			obj->mRank = val;
-		}
-
-	public:
-		ScriptSerializableTypeInfoArrayRTTI()
-		{
-			addReflectablePtrField("mElementType", 0, &ScriptSerializableTypeInfoArrayRTTI::getElementType, &ScriptSerializableTypeInfoArrayRTTI::setElementType);
-			addPlainField("mRank", 1, &ScriptSerializableTypeInfoArrayRTTI::getRank, &ScriptSerializableTypeInfoArrayRTTI::setRank);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableTypeInfoArray";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableTypeInfoArray;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableTypeInfoArray>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoListRTTI : public RTTIType<ScriptSerializableTypeInfoList, ScriptSerializableTypeInfo, ScriptSerializableTypeInfoListRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoPtr getElementType(ScriptSerializableTypeInfoList* obj)
-		{
-			return obj->mElementType;
-		}
-
-		void setElementType(ScriptSerializableTypeInfoList* obj, ScriptSerializableTypeInfoPtr val)
-		{
-			obj->mElementType = val;
-		}
-
-	public:
-		ScriptSerializableTypeInfoListRTTI()
-		{
-			addReflectablePtrField("mElementType", 0, &ScriptSerializableTypeInfoListRTTI::getElementType, &ScriptSerializableTypeInfoListRTTI::setElementType);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableTypeInfoList";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableTypeInfoList;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableTypeInfoList>();
-		}
-	};
-
-	class BS_SCR_BE_EXPORT ScriptSerializableTypeInfoDictionaryRTTI : public RTTIType<ScriptSerializableTypeInfoDictionary, ScriptSerializableTypeInfo, ScriptSerializableTypeInfoDictionaryRTTI>
-	{
-	private:
-		ScriptSerializableTypeInfoPtr getKeyType(ScriptSerializableTypeInfoDictionary* obj)
-		{
-			return obj->mKeyType;
-		}
-
-		void setKeyType(ScriptSerializableTypeInfoDictionary* obj, ScriptSerializableTypeInfoPtr val)
-		{
-			obj->mKeyType = val;
-		}
-
-		ScriptSerializableTypeInfoPtr getValueType(ScriptSerializableTypeInfoDictionary* obj)
-		{
-			return obj->mValueType;
-		}
-
-		void setValueType(ScriptSerializableTypeInfoDictionary* obj, ScriptSerializableTypeInfoPtr val)
-		{
-			obj->mValueType = val;
-		}
-
-	public:
-		ScriptSerializableTypeInfoDictionaryRTTI()
-		{
-			addReflectablePtrField("mKeyType", 0, &ScriptSerializableTypeInfoDictionaryRTTI::getKeyType, &ScriptSerializableTypeInfoDictionaryRTTI::setKeyType);
-			addReflectablePtrField("mValueType", 1, &ScriptSerializableTypeInfoDictionaryRTTI::getValueType, &ScriptSerializableTypeInfoDictionaryRTTI::setValueType);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableTypeInfoDictionary";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_SerializableTypeInfoDictionary;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return cm_shared_ptr<ScriptSerializableTypeInfoDictionary>();
-		}
-	};
-}

SBansheeEngine/Include/BsScriptSerializableObjectRTTI.h

@@ -1,88 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "CmRTTIType.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsScriptSerializableObject.h"
-#include "BsScriptSerializableField.h"
-#include "CmGameObjectManager.h"
-#include "BsMonoClass.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableObjectRTTI : public RTTIType<ScriptSerializableObject, IReflectable, ScriptSerializableObjectRTTI>
-	{
-	private:
-		ScriptSerializableObjectInfoPtr getInfo(ScriptSerializableObject* obj)
-		{
-			return obj->mObjInfo;
-		}
-
-		void setInfo(ScriptSerializableObject* obj, ScriptSerializableObjectInfoPtr val)
-		{
-			obj->mObjInfo = val;
-		}
-
-		ScriptSerializableFieldDataEntryPtr getFieldEntry(ScriptSerializableObject* obj, UINT32 arrayIdx)
-		{
-			return obj->mFieldEntries[arrayIdx];
-		}
-
-		void setFieldsEntry(ScriptSerializableObject* obj, UINT32 arrayIdx, ScriptSerializableFieldDataEntryPtr val)
-		{
-			obj->mFieldEntries[arrayIdx] = val;
-		}
-
-		UINT32 getNumFieldEntries(ScriptSerializableObject* obj)
-		{
-			return (UINT32)obj->mFieldEntries.size();
-		}
-
-		void setNumFieldEntries(ScriptSerializableObject* obj, UINT32 numEntries)
-		{
-			obj->mFieldEntries.resize(numEntries);
-		}
-
-	public:
-		ScriptSerializableObjectRTTI()
-		{
-			addReflectablePtrField("mObjInfo", 0, &ScriptSerializableObjectRTTI::getInfo, &ScriptSerializableObjectRTTI::setInfo);
-			addReflectablePtrArrayField("mFieldEntries", 1, &ScriptSerializableObjectRTTI::getFieldEntry, &ScriptSerializableObjectRTTI::getNumFieldEntries, 
-				&ScriptSerializableObjectRTTI::setFieldsEntry, &ScriptSerializableObjectRTTI::setNumFieldEntries);
-		}
-
-		virtual void onSerializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableObject* serializableObject = static_cast<ScriptSerializableObject*>(obj);
-			serializableObject->serializeManagedInstance();
-		}
-
-		virtual void onDeserializationStarted(IReflectable* obj)
-		{
-			ScriptSerializableObject* serializableObject = static_cast<ScriptSerializableObject*>(obj);
-
-			// If we are deserializing a GameObject we need to defer deserializing actual field values
-			// to ensure GameObject handles instances have been fixed up (which only happens after deserialization is done)
-			if(GameObjectManager::instance().isGameObjectDeserializationActive())
-				GameObjectManager::instance().registerOnDeserializationEndCallback([=] () { serializableObject->deserializeManagedInstance(); });
-			else
-				serializableObject->deserializeManagedInstance();
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ScriptSerializableObject";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_ScriptSerializableObject;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return ScriptSerializableObject::createEmpty();
-		}
-	};
-}

SBansheeEngine/SBansheeEngine.vcxproj

@@ -228,15 +228,15 @@
   <ItemGroup>
     <ClInclude Include="Include\BsManagedComponent.h" />
     <ClInclude Include="Include\BsManagedComponentRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableArray.h" />
-    <ClInclude Include="Include\BsScriptSerializableArrayRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableDictionary.h" />
-    <ClInclude Include="Include\BsScriptSerializableDictionaryRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableField.h" />
-    <ClInclude Include="Include\BsScriptSerializableFieldRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableList.h" />
-    <ClInclude Include="Include\BsScriptSerializableListRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableObject.h" />
+    <ClInclude Include="Include\BsManagedSerializableArray.h" />
+    <ClInclude Include="Include\BsManagedSerializableArrayRTTI.h" />
+    <ClInclude Include="Include\BsManagedSerializableDictionary.h" />
+    <ClInclude Include="Include\BsManagedSerializableDictionaryRTTI.h" />
+    <ClInclude Include="Include\BsManagedSerializableField.h" />
+    <ClInclude Include="Include\BsManagedSerializableFieldRTTI.h" />
+    <ClInclude Include="Include\BsManagedSerializableList.h" />
+    <ClInclude Include="Include\BsManagedSerializableListRTTI.h" />
+    <ClInclude Include="Include\BsManagedSerializableObject.h" />
     <ClInclude Include="Include\BsRuntimeScriptObjects.h" />
     <ClInclude Include="Include\BsScriptComponent.h" />
     <ClInclude Include="Include\BsScriptEnginePrerequisites.h" />
@@ -264,13 +264,13 @@
     <ClInclude Include="Include\BsScriptResource.h" />
     <ClInclude Include="Include\BsScriptResourceManager.h" />
     <ClInclude Include="Include\BsScriptSceneObject.h" />
-    <ClInclude Include="Include\BsScriptSerializableObjectInfoRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableObjectRTTI.h" />
+    <ClInclude Include="Include\BsManagedSerializableObjectInfoRTTI.h" />
+    <ClInclude Include="Include\BsManagedSerializableObjectRTTI.h" />
     <ClInclude Include="Include\BsScriptSpriteTexture.h" />
     <ClInclude Include="Include\BsScriptStringTable.h" />
     <ClInclude Include="Include\BsScriptTexture2D.h" />
     <ClInclude Include="Include\BsScriptGUIContent.h" />
-    <ClInclude Include="Include\BsScriptSerializableObjectInfo.h" />
+    <ClInclude Include="Include\BsManagedSerializableObjectInfo.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsManagedComponent.cpp" />
@@ -297,12 +297,12 @@
     <ClCompile Include="Source\BsScriptGUIInputBox.cpp" />
     <ClCompile Include="Source\BsScriptResourceManager.cpp" />
     <ClCompile Include="Source\BsScriptSceneObject.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableArray.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableDictionary.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableField.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableList.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableObject.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableObjectInfo.cpp" />
+    <ClCompile Include="Source\BsManagedSerializableArray.cpp" />
+    <ClCompile Include="Source\BsManagedSerializableDictionary.cpp" />
+    <ClCompile Include="Source\BsManagedSerializableField.cpp" />
+    <ClCompile Include="Source\BsManagedSerializableList.cpp" />
+    <ClCompile Include="Source\BsManagedSerializableObject.cpp" />
+    <ClCompile Include="Source\BsManagedSerializableObjectInfo.cpp" />
     <ClCompile Include="Source\BsScriptSpriteTexture.cpp" />
     <ClCompile Include="Source\BsScriptStringTable.cpp" />
     <ClCompile Include="Source\BsScriptTexture2D.cpp" />

SBansheeEngine/SBansheeEngine.vcxproj.filters

@@ -19,6 +19,15 @@
     <Filter Include="Source Files\GUI">
       <UniqueIdentifier>{a412791a-7e2f-4aea-a34f-6c2ad7f1246c}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\Serialization">
+      <UniqueIdentifier>{97b82061-c2d8-49e4-8840-80ff956f2cc0}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Serialization">
+      <UniqueIdentifier>{10d91e2d-e560-4081-ac15-bc6753ca2a7e}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Serialization\RTTI">
+      <UniqueIdentifier>{3225801f-fe74-4e07-aa59-37ad5d5ac1da}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Include\BsScriptFont.h">
@@ -45,9 +54,6 @@
     <ClInclude Include="Include\BsScriptHString.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsRuntimeScriptObjects.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\BsManagedComponent.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -72,42 +78,6 @@
     <ClInclude Include="Include\BsScriptSceneObject.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableObjectInfo.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableObjectInfoRTTI.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableObject.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableObjectRTTI.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableField.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableArrayRTTI.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableFieldRTTI.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableList.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableListRTTI.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableDictionary.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableDictionaryRTTI.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\BsScriptGUIArea.h">
       <Filter>Header Files\GUI</Filter>
     </ClInclude>
@@ -156,6 +126,45 @@
     <ClInclude Include="Include\BsScriptGUIPanel.h">
       <Filter>Header Files\GUI</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsRuntimeScriptObjects.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableArrayRTTI.h">
+      <Filter>Header Files\Serialization\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableDictionaryRTTI.h">
+      <Filter>Header Files\Serialization\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableListRTTI.h">
+      <Filter>Header Files\Serialization\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableObjectRTTI.h">
+      <Filter>Header Files\Serialization\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableArray.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableDictionary.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableList.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableObject.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableFieldRTTI.h">
+      <Filter>Header Files\Serialization\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableObjectInfoRTTI.h">
+      <Filter>Header Files\Serialization\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableField.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsManagedSerializableObjectInfo.h">
+      <Filter>Header Files\Serialization</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptTexture2D.cpp">
@@ -176,9 +185,6 @@
     <ClCompile Include="Source\BsScriptStringTable.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\BsRuntimeScriptObjects.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\BsManagedComponent.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -194,24 +200,6 @@
     <ClCompile Include="Source\BsScriptSceneObject.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableObjectInfo.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableObject.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableArray.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableField.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableList.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableDictionary.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\BsScriptGUIArea.cpp">
       <Filter>Source Files\GUI</Filter>
     </ClCompile>
@@ -260,5 +248,26 @@
     <ClCompile Include="Source\BsScriptGUIPanel.cpp">
       <Filter>Source Files\GUI</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsRuntimeScriptObjects.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsManagedSerializableArray.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsManagedSerializableDictionary.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsManagedSerializableField.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsManagedSerializableList.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsManagedSerializableObject.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsManagedSerializableObjectInfo.cpp">
+      <Filter>Source Files\Serialization</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEngine/Source/BsScriptSerializableArray.cpp → SBansheeEngine/Source/BsManagedSerializableArray.cpp

@@ -1,183 +1,183 @@
-#include "BsScriptSerializableArray.h"
-#include "BsScriptSerializableArrayRTTI.h"
-#include "BsMonoManager.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsScriptSerializableField.h"
-#include "BsMonoClass.h"
-#include "BsMonoMethod.h"
-
-namespace BansheeEngine
-{
-	ScriptSerializableArray::ScriptSerializableArray(const ConstructPrivately& dummy)
-		:mManagedInstance(nullptr), mElemSize(0), mElementMonoClass(nullptr)
-	{
-
-	}
-
-	ScriptSerializableArray::ScriptSerializableArray(const ConstructPrivately& dummy, const ScriptSerializableTypeInfoArrayPtr& typeInfo, MonoObject* managedInstance)
-		:mArrayTypeInfo(typeInfo), mManagedInstance(managedInstance), mElemSize(0), mElementMonoClass(nullptr)
-	{
-		::MonoClass* monoClass = mono_object_get_class(mManagedInstance);
-		mElemSize = mono_array_element_size(monoClass);
-
-		initMonoObjects();
-
-		mNumElements.resize(typeInfo->mRank);
-		for(UINT32 i = 0; i < typeInfo->mRank; i++)
-			mNumElements[i] = getLength(i);
-	}
-
-	ScriptSerializableArrayPtr ScriptSerializableArray::create(MonoObject* managedInstance, const ScriptSerializableTypeInfoArrayPtr& typeInfo)
-	{
-		if(managedInstance == nullptr)
-			return nullptr;
-
-		if(!RuntimeScriptObjects::instance().getSystemArrayClass()->isInstanceOfType(managedInstance))
-			return nullptr;
-
-		return cm_shared_ptr<ScriptSerializableArray>(ConstructPrivately(), typeInfo, managedInstance);
-	}
-
-	ScriptSerializableArrayPtr ScriptSerializableArray::createEmpty()
-	{
-		return cm_shared_ptr<ScriptSerializableArray>(ConstructPrivately());
-	}
-
-	void ScriptSerializableArray::serializeManagedInstance()
-	{
-		UINT32 totalNumElements = 1;
-		for(auto& numElems : mNumElements)
-		{
-			totalNumElements *= numElems;
-		}
-
-		mArrayEntries.resize(totalNumElements);
-		for(UINT32 i = 0; i < totalNumElements; i++)
-		{
-			mArrayEntries[i] = getFieldData(i);
-		}
-	}
-
-	void ScriptSerializableArray::deserializeManagedInstance()
-	{
-		if(!mArrayTypeInfo->isTypeLoaded())
-			return;
-
-		MonoClass* arrayClass = RuntimeScriptObjects::instance().getSystemArrayClass();
-
-		MonoMethod* createInstance = arrayClass->getMethodExact("CreateInstance", "Type,int[]");
-		MonoArray* lengthArray = mono_array_new(MonoManager::instance().getDomain(), mono_get_int32_class(), (UINT32)mNumElements.size());
-
-		for(UINT32 i = 0; i < (UINT32)mNumElements.size(); i++)
-		{
-			void* elemAddr = mono_array_addr_with_size(lengthArray, sizeof(int), i);
-			memcpy(elemAddr, &mNumElements[i], sizeof(int));
-		}
-
-		void* params[2] = { 
-			mono_type_get_object(MonoManager::instance().getDomain(), mono_class_get_type(mArrayTypeInfo->getMonoClass())), lengthArray };
-
-		mManagedInstance = createInstance->invoke(nullptr, params);
-		initMonoObjects();
-
-		UINT32 idx = 0;
-		for(auto& arrayEntry : mArrayEntries)
-		{
-			setFieldData(idx, arrayEntry);
-			idx++;
-		}
-	}
-
-	void ScriptSerializableArray::setFieldData(UINT32 arrayIdx, const ScriptSerializableFieldDataPtr& val)
-	{
-		if(mono_class_is_valuetype(mElementMonoClass))
-			setValue(arrayIdx, val->getValue(mArrayTypeInfo->mElementType));
-		else
-		{
-			MonoObject* ptrToObj = (MonoObject*)val->getValue(mArrayTypeInfo->mElementType);
-			setValue(arrayIdx, &ptrToObj);
-		}
-	}
-
-	ScriptSerializableFieldDataPtr ScriptSerializableArray::getFieldData(UINT32 arrayIdx)
-	{
-		MonoArray* array = (MonoArray*)mManagedInstance;
-
-		UINT32 numElems = (UINT32)mono_array_length(array);
-		assert(arrayIdx < numElems);
-
-		void* arrayValue = mono_array_addr_with_size(array, mElemSize, arrayIdx);
-
-		if(mono_class_is_valuetype(mElementMonoClass))
-		{
-			MonoObject* boxedObj = nullptr;
-
-			if(arrayValue != nullptr)
-				boxedObj = mono_value_box(MonoManager::instance().getDomain(), mElementMonoClass, arrayValue);
-
-			return ScriptSerializableFieldData::create(mArrayTypeInfo->mElementType, boxedObj);
-		}
-		else
-			return ScriptSerializableFieldData::create(mArrayTypeInfo->mElementType, *(MonoObject**)arrayValue);
-	}
-	
-	void ScriptSerializableArray::setValue(UINT32 arrayIdx, void* val)
-	{
-		MonoArray* array = (MonoArray*)mManagedInstance;
-
-		UINT32 numElems = (UINT32)mono_array_length(array);
-		assert(arrayIdx < numElems);
-	
-		void* elemAddr = mono_array_addr_with_size(array, mElemSize, arrayIdx);
-		memcpy(elemAddr, val, mElemSize);
-	}
-
-	void ScriptSerializableArray::initMonoObjects()
-	{
-		mElementMonoClass = mArrayTypeInfo->mElementType->getMonoClass();
-	}
-
-	UINT32 ScriptSerializableArray::toSequentialIdx(const Vector<UINT32>::type& idx) const
-	{
-		UINT32 mNumDims = (UINT32)mNumElements.size();
-
-		if(idx.size() != mNumDims)
-			CM_EXCEPT(InvalidParametersException, "Provided index doesn't have the correct number of dimensions");
-
-		if(mNumElements.size() == 0)
-			return 0;
-
-		UINT32 curIdx = 0;
-		UINT32 prevDimensionSize = 1;
-		
-		for(INT32 i = mNumDims - 1; i >= 0; i--)
-		{
-			curIdx += idx[i] * prevDimensionSize;
-
-			prevDimensionSize *= mNumElements[i];
-		}
-
-		return curIdx;
-	}
-
-	UINT32 ScriptSerializableArray::getLength(UINT32 dimension) const
-	{
-		MonoClass* systemArray = RuntimeScriptObjects::instance().getSystemArrayClass();
-		MonoMethod& getLength = systemArray->getMethod("GetLength", 1);
-
-		void* params[1] = { &dimension };
-		MonoObject* returnObj = getLength.invoke(mManagedInstance, params);
-
-		return *(UINT32*)mono_object_unbox(returnObj);
-	}
-
-	RTTITypeBase* ScriptSerializableArray::getRTTIStatic()
-	{
-		return ScriptSerializableArrayRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableArray::getRTTI() const
-	{
-		return ScriptSerializableArray::getRTTIStatic();
-	}
+#include "BsManagedSerializableArray.h"
+#include "BsManagedSerializableArrayRTTI.h"
+#include "BsMonoManager.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsManagedSerializableField.h"
+#include "BsMonoClass.h"
+#include "BsMonoMethod.h"
+
+namespace BansheeEngine
+{
+	ManagedSerializableArray::ManagedSerializableArray(const ConstructPrivately& dummy)
+		:mManagedInstance(nullptr), mElemSize(0), mElementMonoClass(nullptr)
+	{
+
+	}
+
+	ManagedSerializableArray::ManagedSerializableArray(const ConstructPrivately& dummy, const ManagedSerializableTypeInfoArrayPtr& typeInfo, MonoObject* managedInstance)
+		:mArrayTypeInfo(typeInfo), mManagedInstance(managedInstance), mElemSize(0), mElementMonoClass(nullptr)
+	{
+		::MonoClass* monoClass = mono_object_get_class(mManagedInstance);
+		mElemSize = mono_array_element_size(monoClass);
+
+		initMonoObjects();
+
+		mNumElements.resize(typeInfo->mRank);
+		for(UINT32 i = 0; i < typeInfo->mRank; i++)
+			mNumElements[i] = getLength(i);
+	}
+
+	ManagedSerializableArrayPtr ManagedSerializableArray::create(MonoObject* managedInstance, const ManagedSerializableTypeInfoArrayPtr& typeInfo)
+	{
+		if(managedInstance == nullptr)
+			return nullptr;
+
+		if(!RuntimeScriptObjects::instance().getSystemArrayClass()->isInstanceOfType(managedInstance))
+			return nullptr;
+
+		return cm_shared_ptr<ManagedSerializableArray>(ConstructPrivately(), typeInfo, managedInstance);
+	}
+
+	ManagedSerializableArrayPtr ManagedSerializableArray::createEmpty()
+	{
+		return cm_shared_ptr<ManagedSerializableArray>(ConstructPrivately());
+	}
+
+	void ManagedSerializableArray::serializeManagedInstance()
+	{
+		UINT32 totalNumElements = 1;
+		for(auto& numElems : mNumElements)
+		{
+			totalNumElements *= numElems;
+		}
+
+		mArrayEntries.resize(totalNumElements);
+		for(UINT32 i = 0; i < totalNumElements; i++)
+		{
+			mArrayEntries[i] = getFieldData(i);
+		}
+	}
+
+	void ManagedSerializableArray::deserializeManagedInstance()
+	{
+		if(!mArrayTypeInfo->isTypeLoaded())
+			return;
+
+		MonoClass* arrayClass = RuntimeScriptObjects::instance().getSystemArrayClass();
+
+		MonoMethod* createInstance = arrayClass->getMethodExact("CreateInstance", "Type,int[]");
+		MonoArray* lengthArray = mono_array_new(MonoManager::instance().getDomain(), mono_get_int32_class(), (UINT32)mNumElements.size());
+
+		for(UINT32 i = 0; i < (UINT32)mNumElements.size(); i++)
+		{
+			void* elemAddr = mono_array_addr_with_size(lengthArray, sizeof(int), i);
+			memcpy(elemAddr, &mNumElements[i], sizeof(int));
+		}
+
+		void* params[2] = { 
+			mono_type_get_object(MonoManager::instance().getDomain(), mono_class_get_type(mArrayTypeInfo->getMonoClass())), lengthArray };
+
+		mManagedInstance = createInstance->invoke(nullptr, params);
+		initMonoObjects();
+
+		UINT32 idx = 0;
+		for(auto& arrayEntry : mArrayEntries)
+		{
+			setFieldData(idx, arrayEntry);
+			idx++;
+		}
+	}
+
+	void ManagedSerializableArray::setFieldData(UINT32 arrayIdx, const ManagedSerializableFieldDataPtr& val)
+	{
+		if(mono_class_is_valuetype(mElementMonoClass))
+			setValue(arrayIdx, val->getValue(mArrayTypeInfo->mElementType));
+		else
+		{
+			MonoObject* ptrToObj = (MonoObject*)val->getValue(mArrayTypeInfo->mElementType);
+			setValue(arrayIdx, &ptrToObj);
+		}
+	}
+
+	ManagedSerializableFieldDataPtr ManagedSerializableArray::getFieldData(UINT32 arrayIdx)
+	{
+		MonoArray* array = (MonoArray*)mManagedInstance;
+
+		UINT32 numElems = (UINT32)mono_array_length(array);
+		assert(arrayIdx < numElems);
+
+		void* arrayValue = mono_array_addr_with_size(array, mElemSize, arrayIdx);
+
+		if(mono_class_is_valuetype(mElementMonoClass))
+		{
+			MonoObject* boxedObj = nullptr;
+
+			if(arrayValue != nullptr)
+				boxedObj = mono_value_box(MonoManager::instance().getDomain(), mElementMonoClass, arrayValue);
+
+			return ManagedSerializableFieldData::create(mArrayTypeInfo->mElementType, boxedObj);
+		}
+		else
+			return ManagedSerializableFieldData::create(mArrayTypeInfo->mElementType, *(MonoObject**)arrayValue);
+	}
+	
+	void ManagedSerializableArray::setValue(UINT32 arrayIdx, void* val)
+	{
+		MonoArray* array = (MonoArray*)mManagedInstance;
+
+		UINT32 numElems = (UINT32)mono_array_length(array);
+		assert(arrayIdx < numElems);
+	
+		void* elemAddr = mono_array_addr_with_size(array, mElemSize, arrayIdx);
+		memcpy(elemAddr, val, mElemSize);
+	}
+
+	void ManagedSerializableArray::initMonoObjects()
+	{
+		mElementMonoClass = mArrayTypeInfo->mElementType->getMonoClass();
+	}
+
+	UINT32 ManagedSerializableArray::toSequentialIdx(const Vector<UINT32>::type& idx) const
+	{
+		UINT32 mNumDims = (UINT32)mNumElements.size();
+
+		if(idx.size() != mNumDims)
+			CM_EXCEPT(InvalidParametersException, "Provided index doesn't have the correct number of dimensions");
+
+		if(mNumElements.size() == 0)
+			return 0;
+
+		UINT32 curIdx = 0;
+		UINT32 prevDimensionSize = 1;
+		
+		for(INT32 i = mNumDims - 1; i >= 0; i--)
+		{
+			curIdx += idx[i] * prevDimensionSize;
+
+			prevDimensionSize *= mNumElements[i];
+		}
+
+		return curIdx;
+	}
+
+	UINT32 ManagedSerializableArray::getLength(UINT32 dimension) const
+	{
+		MonoClass* systemArray = RuntimeScriptObjects::instance().getSystemArrayClass();
+		MonoMethod& getLength = systemArray->getMethod("GetLength", 1);
+
+		void* params[1] = { &dimension };
+		MonoObject* returnObj = getLength.invoke(mManagedInstance, params);
+
+		return *(UINT32*)mono_object_unbox(returnObj);
+	}
+
+	RTTITypeBase* ManagedSerializableArray::getRTTIStatic()
+	{
+		return ManagedSerializableArrayRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableArray::getRTTI() const
+	{
+		return ManagedSerializableArray::getRTTIStatic();
+	}
 }

SBansheeEngine/Source/BsScriptSerializableDictionary.cpp → SBansheeEngine/Source/BsManagedSerializableDictionary.cpp

@@ -1,158 +1,158 @@
-#include "BsScriptSerializableDictionary.h"
-#include "BsScriptSerializableDictionaryRTTI.h"
-#include "BsMonoManager.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsScriptSerializableField.h"
-#include "BsMonoClass.h"
-#include "BsMonoMethod.h"
-#include "BsMonoProperty.h"
-
-namespace BansheeEngine
-{
-	ScriptSerializableDictionary::Enumerator::Enumerator(MonoObject* instance, const ScriptSerializableDictionary* parent)
-		:mInstance(instance), mParent(parent), mCurrent(nullptr)
-	{ }
-
-	ScriptSerializableFieldDataPtr ScriptSerializableDictionary::Enumerator::getKey() const
-	{
-		MonoObject* obj = mParent->mKeyProp->get(mCurrent);
-
-		return ScriptSerializableFieldData::create(mParent->mDictionaryTypeInfo->mKeyType, obj);
-	}
-
-	ScriptSerializableFieldDataPtr ScriptSerializableDictionary::Enumerator::getValue() const
-	{
-		MonoObject* obj = mParent->mValueProp->get(mCurrent);
-
-		return ScriptSerializableFieldData::create(mParent->mDictionaryTypeInfo->mValueType, obj);
-	}
-
-	bool ScriptSerializableDictionary::Enumerator::moveNext()
-	{
-		MonoObject* returnVal = mParent->mEnumMoveNext->invoke(mInstance, nullptr);
-		bool isValid = *(bool*)mono_object_unbox(returnVal);
-
-		if(isValid)
-			mCurrent = (MonoObject*)mono_object_unbox(mParent->mEnumCurrentProp->get(mInstance));
-		else
-			mCurrent = nullptr;
-
-		return isValid;
-	}
-
-	ScriptSerializableDictionary::ScriptSerializableDictionary(const ConstructPrivately& dummy)
-		:mManagedInstance(nullptr), mAddMethod(nullptr), mGetEnumerator(nullptr), mEnumMoveNext(nullptr),
-		mEnumCurrentProp(nullptr), mKeyProp(nullptr), mValueProp(nullptr)
-	{ }
-
-	ScriptSerializableDictionary::ScriptSerializableDictionary(const ConstructPrivately& dummy, const ScriptSerializableTypeInfoDictionaryPtr& typeInfo, MonoObject* managedInstance)
-		:mDictionaryTypeInfo(typeInfo), mManagedInstance(managedInstance), mAddMethod(nullptr), mGetEnumerator(nullptr), mEnumMoveNext(nullptr),
-		mEnumCurrentProp(nullptr), mKeyProp(nullptr), mValueProp(nullptr)
-	{
-
-	}
-
-	ScriptSerializableDictionaryPtr ScriptSerializableDictionary::create(MonoObject* managedInstance, const ScriptSerializableTypeInfoDictionaryPtr& typeInfo)
-	{
-		if(managedInstance == nullptr)
-			return nullptr;
-
-		::MonoClass* monoClass = mono_object_get_class(managedInstance);
-		String elementNs = mono_class_get_namespace(monoClass);
-		String elementTypeName = mono_class_get_name(monoClass);
-		String fullName = elementNs + "." + elementTypeName;
-
-		if(RuntimeScriptObjects::instance().getSystemGenericDictionaryClass()->getFullName() != fullName)
-			return nullptr;
-
-		return cm_shared_ptr<ScriptSerializableDictionary>(ConstructPrivately(), typeInfo, managedInstance);
-	}
-
-	ScriptSerializableDictionaryPtr ScriptSerializableDictionary::createEmpty()
-	{
-		return cm_shared_ptr<ScriptSerializableDictionary>(ConstructPrivately());
-	}
-
-	void ScriptSerializableDictionary::serializeManagedInstance()
-	{
-		MonoClass* dictionaryClass = MonoManager::instance().findClass(mono_object_get_class(mManagedInstance));
-		if(dictionaryClass == nullptr)
-			return;
-
-		initMonoObjects(dictionaryClass);
-
-		mKeyEntries.clear();
-		mValueEntries.clear();
-
-		Enumerator enumerator = getEnumerator();
-
-		while(enumerator.moveNext())
-		{
-			mKeyEntries.push_back(enumerator.getKey());
-			mValueEntries.push_back(enumerator.getValue());
-		}
-	}
-
-	void ScriptSerializableDictionary::deserializeManagedInstance()
-	{
-		if(!mDictionaryTypeInfo->isTypeLoaded())
-			return;
-
-		::MonoClass* dictionaryMonoClass = mDictionaryTypeInfo->getMonoClass();
-		MonoClass* dictionaryClass = MonoManager::instance().findClass(dictionaryMonoClass);
-		if(dictionaryClass == nullptr)
-			return;
-
-		initMonoObjects(dictionaryClass);
-
-		mManagedInstance = dictionaryClass->createInstance();
-		assert(mKeyEntries.size() == mValueEntries.size());
-
-		for(UINT32 i = 0; i < (UINT32)mKeyEntries.size(); i++)
-		{
-			setFieldData(mKeyEntries[i], mValueEntries[i]);
-		}
-	}
-
-	void ScriptSerializableDictionary::setFieldData(const ScriptSerializableFieldDataPtr& key, const ScriptSerializableFieldDataPtr& val)
-	{
-		void* params[2];
-		params[0] = key->getValue(mDictionaryTypeInfo->mKeyType);
-		params[1] = val->getValue(mDictionaryTypeInfo->mValueType);
-
-		mAddMethod->invoke(mManagedInstance, params);
-	}
-
-	ScriptSerializableDictionary::Enumerator ScriptSerializableDictionary::getEnumerator() const
-	{
-		return Enumerator((MonoObject*)mono_object_unbox(mGetEnumerator->invoke(mManagedInstance, nullptr)), this);
-	}
-
-	void ScriptSerializableDictionary::initMonoObjects(MonoClass* dictionaryClass)
-	{
-		mAddMethod = &dictionaryClass->getMethod("Add", 2);
-		mGetEnumerator = &dictionaryClass->getMethod("GetEnumerator");
-
-		MonoClass* enumeratorClass = mGetEnumerator->getReturnType();
-		assert(enumeratorClass != nullptr);
-
-		mEnumMoveNext = &enumeratorClass->getMethod("MoveNext");
-		mEnumCurrentProp = &enumeratorClass->getProperty("Current");
-
-		MonoClass* keyValuePairClass = mEnumCurrentProp->getReturnType();
-		assert(keyValuePairClass != nullptr);
-
-		mKeyProp = &keyValuePairClass->getProperty("Key");
-		mValueProp = &keyValuePairClass->getProperty("Value");
-	}
-
-	RTTITypeBase* ScriptSerializableDictionary::getRTTIStatic()
-	{
-		return ScriptSerializableDictionaryRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableDictionary::getRTTI() const
-	{
-		return ScriptSerializableDictionary::getRTTIStatic();
-	}
+#include "BsManagedSerializableDictionary.h"
+#include "BsManagedSerializableDictionaryRTTI.h"
+#include "BsMonoManager.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsManagedSerializableField.h"
+#include "BsMonoClass.h"
+#include "BsMonoMethod.h"
+#include "BsMonoProperty.h"
+
+namespace BansheeEngine
+{
+	ManagedSerializableDictionary::Enumerator::Enumerator(MonoObject* instance, const ManagedSerializableDictionary* parent)
+		:mInstance(instance), mParent(parent), mCurrent(nullptr)
+	{ }
+
+	ManagedSerializableFieldDataPtr ManagedSerializableDictionary::Enumerator::getKey() const
+	{
+		MonoObject* obj = mParent->mKeyProp->get(mCurrent);
+
+		return ManagedSerializableFieldData::create(mParent->mDictionaryTypeInfo->mKeyType, obj);
+	}
+
+	ManagedSerializableFieldDataPtr ManagedSerializableDictionary::Enumerator::getValue() const
+	{
+		MonoObject* obj = mParent->mValueProp->get(mCurrent);
+
+		return ManagedSerializableFieldData::create(mParent->mDictionaryTypeInfo->mValueType, obj);
+	}
+
+	bool ManagedSerializableDictionary::Enumerator::moveNext()
+	{
+		MonoObject* returnVal = mParent->mEnumMoveNext->invoke(mInstance, nullptr);
+		bool isValid = *(bool*)mono_object_unbox(returnVal);
+
+		if(isValid)
+			mCurrent = (MonoObject*)mono_object_unbox(mParent->mEnumCurrentProp->get(mInstance));
+		else
+			mCurrent = nullptr;
+
+		return isValid;
+	}
+
+	ManagedSerializableDictionary::ManagedSerializableDictionary(const ConstructPrivately& dummy)
+		:mManagedInstance(nullptr), mAddMethod(nullptr), mGetEnumerator(nullptr), mEnumMoveNext(nullptr),
+		mEnumCurrentProp(nullptr), mKeyProp(nullptr), mValueProp(nullptr)
+	{ }
+
+	ManagedSerializableDictionary::ManagedSerializableDictionary(const ConstructPrivately& dummy, const ManagedSerializableTypeInfoDictionaryPtr& typeInfo, MonoObject* managedInstance)
+		:mDictionaryTypeInfo(typeInfo), mManagedInstance(managedInstance), mAddMethod(nullptr), mGetEnumerator(nullptr), mEnumMoveNext(nullptr),
+		mEnumCurrentProp(nullptr), mKeyProp(nullptr), mValueProp(nullptr)
+	{
+
+	}
+
+	ManagedSerializableDictionaryPtr ManagedSerializableDictionary::create(MonoObject* managedInstance, const ManagedSerializableTypeInfoDictionaryPtr& typeInfo)
+	{
+		if(managedInstance == nullptr)
+			return nullptr;
+
+		::MonoClass* monoClass = mono_object_get_class(managedInstance);
+		String elementNs = mono_class_get_namespace(monoClass);
+		String elementTypeName = mono_class_get_name(monoClass);
+		String fullName = elementNs + "." + elementTypeName;
+
+		if(RuntimeScriptObjects::instance().getSystemGenericDictionaryClass()->getFullName() != fullName)
+			return nullptr;
+
+		return cm_shared_ptr<ManagedSerializableDictionary>(ConstructPrivately(), typeInfo, managedInstance);
+	}
+
+	ManagedSerializableDictionaryPtr ManagedSerializableDictionary::createEmpty()
+	{
+		return cm_shared_ptr<ManagedSerializableDictionary>(ConstructPrivately());
+	}
+
+	void ManagedSerializableDictionary::serializeManagedInstance()
+	{
+		MonoClass* dictionaryClass = MonoManager::instance().findClass(mono_object_get_class(mManagedInstance));
+		if(dictionaryClass == nullptr)
+			return;
+
+		initMonoObjects(dictionaryClass);
+
+		mKeyEntries.clear();
+		mValueEntries.clear();
+
+		Enumerator enumerator = getEnumerator();
+
+		while(enumerator.moveNext())
+		{
+			mKeyEntries.push_back(enumerator.getKey());
+			mValueEntries.push_back(enumerator.getValue());
+		}
+	}
+
+	void ManagedSerializableDictionary::deserializeManagedInstance()
+	{
+		if(!mDictionaryTypeInfo->isTypeLoaded())
+			return;
+
+		::MonoClass* dictionaryMonoClass = mDictionaryTypeInfo->getMonoClass();
+		MonoClass* dictionaryClass = MonoManager::instance().findClass(dictionaryMonoClass);
+		if(dictionaryClass == nullptr)
+			return;
+
+		initMonoObjects(dictionaryClass);
+
+		mManagedInstance = dictionaryClass->createInstance();
+		assert(mKeyEntries.size() == mValueEntries.size());
+
+		for(UINT32 i = 0; i < (UINT32)mKeyEntries.size(); i++)
+		{
+			setFieldData(mKeyEntries[i], mValueEntries[i]);
+		}
+	}
+
+	void ManagedSerializableDictionary::setFieldData(const ManagedSerializableFieldDataPtr& key, const ManagedSerializableFieldDataPtr& val)
+	{
+		void* params[2];
+		params[0] = key->getValue(mDictionaryTypeInfo->mKeyType);
+		params[1] = val->getValue(mDictionaryTypeInfo->mValueType);
+
+		mAddMethod->invoke(mManagedInstance, params);
+	}
+
+	ManagedSerializableDictionary::Enumerator ManagedSerializableDictionary::getEnumerator() const
+	{
+		return Enumerator((MonoObject*)mono_object_unbox(mGetEnumerator->invoke(mManagedInstance, nullptr)), this);
+	}
+
+	void ManagedSerializableDictionary::initMonoObjects(MonoClass* dictionaryClass)
+	{
+		mAddMethod = &dictionaryClass->getMethod("Add", 2);
+		mGetEnumerator = &dictionaryClass->getMethod("GetEnumerator");
+
+		MonoClass* enumeratorClass = mGetEnumerator->getReturnType();
+		assert(enumeratorClass != nullptr);
+
+		mEnumMoveNext = &enumeratorClass->getMethod("MoveNext");
+		mEnumCurrentProp = &enumeratorClass->getProperty("Current");
+
+		MonoClass* keyValuePairClass = mEnumCurrentProp->getReturnType();
+		assert(keyValuePairClass != nullptr);
+
+		mKeyProp = &keyValuePairClass->getProperty("Key");
+		mValueProp = &keyValuePairClass->getProperty("Value");
+	}
+
+	RTTITypeBase* ManagedSerializableDictionary::getRTTIStatic()
+	{
+		return ManagedSerializableDictionaryRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableDictionary::getRTTI() const
+	{
+		return ManagedSerializableDictionary::getRTTIStatic();
+	}
 }

SBansheeEngine/Source/BsManagedSerializableField.cpp

@@ -0,0 +1,754 @@
+#include "BsManagedSerializableField.h"
+#include "BsManagedSerializableObjectInfo.h"
+#include "BsManagedSerializableFieldRTTI.h"
+#include "BsMonoUtil.h"
+#include "BsMonoManager.h"
+#include "BsScriptResourceManager.h"
+#include "BsScriptGameObjectManager.h"
+#include "BsScriptTexture2D.h"
+#include "BsScriptSpriteTexture.h"
+#include "BsScriptSceneObject.h"
+#include "BsScriptComponent.h"
+#include "BsManagedSerializableObject.h"
+#include "BsManagedSerializableArray.h"
+#include "BsManagedSerializableList.h"
+#include "BsManagedSerializableDictionary.h"
+
+namespace BansheeEngine
+{
+	ManagedSerializableFieldKeyPtr ManagedSerializableFieldKey::create(UINT16 typeId, UINT16 fieldId)
+	{
+		ManagedSerializableFieldKeyPtr fieldKey = cm_shared_ptr<ManagedSerializableFieldKey>();
+		fieldKey->mTypeId = typeId;
+		fieldKey->mFieldId = fieldId;
+
+		return fieldKey;
+	}
+
+	ManagedSerializableFieldDataEntryPtr ManagedSerializableFieldDataEntry::create(const ManagedSerializableFieldKeyPtr& key, const ManagedSerializableFieldDataPtr& value)
+	{
+		ManagedSerializableFieldDataEntryPtr fieldDataEntry = cm_shared_ptr<ManagedSerializableFieldDataEntry>();
+		fieldDataEntry->mKey = key;
+		fieldDataEntry->mValue = value;
+
+		return fieldDataEntry;
+	}
+
+	ManagedSerializableFieldDataPtr ManagedSerializableFieldData::create(const ManagedSerializableTypeInfoPtr& typeInfo, MonoObject* value)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			switch (primitiveTypeInfo->mType)
+			{
+			case ScriptPrimitiveType::Bool:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataBool>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+
+					return fieldData;
+				}
+			case ScriptPrimitiveType::Char:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataChar>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::I8:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataI8>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::U8:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataU8>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::I16:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataI16>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::U16:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataU16>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::I32:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataI32>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::U32:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataU32>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::I64:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataI64>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::U64:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataU64>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::Float:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataFloat>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::Double:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataDouble>();
+					if(value != nullptr)
+						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+					return fieldData;
+				}
+			case ScriptPrimitiveType::String:
+				{
+					MonoString* strVal = (MonoString*)(value);
+
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataString>();
+					if(strVal != nullptr)
+						fieldData->value = MonoUtil::monoToWString(strVal);
+					return fieldData;
+				}
+			case ScriptPrimitiveType::TextureRef:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataResourceRef>();
+
+					if(value != nullptr)
+					{
+						ScriptTexture2D* scriptTexture2D = ScriptTexture2D::toNative(value);
+						fieldData->value = static_resource_cast<ScriptTexture2D>(scriptTexture2D->getNativeHandle());
+					}
+
+					return fieldData;
+				}
+			case ScriptPrimitiveType::SpriteTextureRef:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataResourceRef>();
+					
+					if(value != nullptr)
+					{
+						ScriptSpriteTexture* scriptSpriteTexture = ScriptSpriteTexture::toNative(value);
+						fieldData->value = static_resource_cast<SpriteTexture>(scriptSpriteTexture->getNativeHandle());
+					}
+
+					return fieldData;
+				}
+			case ScriptPrimitiveType::SceneObjectRef:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataGameObjectRef>();
+
+					if(value != nullptr)
+					{
+						ScriptSceneObject* scriptSceneObject = ScriptSceneObject::toNative(value);
+						fieldData->value = static_object_cast<SceneObject>(scriptSceneObject->getNativeHandle());
+					}
+
+					return fieldData;
+				}
+			case ScriptPrimitiveType::ComponentRef:
+				{
+					auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataGameObjectRef>();
+
+					if(value != nullptr)
+					{
+						ScriptComponent* scriptComponent = ScriptComponent::toNative(value);
+						fieldData->value = static_object_cast<Component>(scriptComponent->getNativeHandle());
+					}
+
+					return fieldData;
+				}
+			}
+		}
+		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoObject)
+		{
+			auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataObject>();
+			if(value != nullptr)
+			{
+				fieldData->value = ManagedSerializableObject::create(value);
+			}
+
+			return fieldData;
+		}
+		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoArray)
+		{
+			auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataArray>();
+			if(value != nullptr)
+			{
+				fieldData->value = ManagedSerializableArray::create(value, std::static_pointer_cast<ManagedSerializableTypeInfoArray>(typeInfo));
+			}
+
+			return fieldData;
+		}
+		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoList)
+		{
+			auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataList>();
+			if(value != nullptr)
+			{
+				fieldData->value = ManagedSerializableList::create(value, std::static_pointer_cast<ManagedSerializableTypeInfoList>(typeInfo));
+			}
+
+			return fieldData;
+		}
+		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoDictionary)
+		{
+			auto fieldData = cm_shared_ptr<ManagedSerializableFieldDataDictionary>();
+			if(value != nullptr)
+			{
+				fieldData->value = ManagedSerializableDictionary::create(value, std::static_pointer_cast<ManagedSerializableTypeInfoDictionary>(typeInfo));
+			}
+
+			return fieldData;
+		}
+
+		return nullptr;
+	}
+
+	void* ManagedSerializableFieldDataBool::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Bool)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataChar::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Char)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataI8::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I8)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataU8::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U8)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataI16::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I16)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataU16::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U16)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataI32::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I32)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataU32::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U32)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataI64::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I64)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataU64::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U64)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataFloat::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Float)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataDouble::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Double)
+				return &value;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataString::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::String)
+			{
+				return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), value);
+			}
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataResourceRef::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::TextureRef)
+			{
+				if(value)
+				{
+					ScriptTexture2D* scriptResource = ScriptResourceManager::instance().getScriptTexture(value);
+					if(scriptResource == nullptr)
+						scriptResource = ScriptResourceManager::instance().createScriptTexture(value);
+
+					return scriptResource->getManagedInstance();
+				}
+				else
+					return nullptr;
+			}
+			else if(primitiveTypeInfo->mType == ScriptPrimitiveType::SpriteTextureRef)
+			{
+				if(value)
+				{
+					ScriptSpriteTexture* scriptResource = ScriptResourceManager::instance().getScriptSpriteTexture(value);
+					if(scriptResource == nullptr)
+						scriptResource = ScriptResourceManager::instance().createScriptSpriteTexture(value);
+
+					if(scriptResource != nullptr)
+						return scriptResource->getManagedInstance();
+				}
+				else
+					return nullptr;
+			}
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataGameObjectRef::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
+		{
+			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+
+			if(primitiveTypeInfo->mType == ScriptPrimitiveType::SceneObjectRef)
+			{
+				if(value)
+				{
+					ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getScriptSceneObject(value);
+					if(scriptSceneObject == nullptr)
+						scriptSceneObject = ScriptGameObjectManager::instance().createScriptSceneObject(value);
+
+					return scriptSceneObject->getManagedInstance();
+				}
+				else
+					return nullptr;
+			}
+			else if(primitiveTypeInfo->mType == ScriptPrimitiveType::ComponentRef)
+			{
+				if(value)
+				{
+					ScriptComponent* scriptComponent = ScriptGameObjectManager::instance().getScriptComponent(value);
+					if(scriptComponent == nullptr)
+						scriptComponent = ScriptGameObjectManager::instance().createScriptComponent(value);
+
+					return scriptComponent->getManagedInstance();
+				}
+				else
+					return nullptr;
+			}
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataObject::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoObject)
+		{
+			auto objectTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoObject>(typeInfo);
+
+			if(value != nullptr)
+			{
+				if(objectTypeInfo->mValueType)
+				{
+					MonoObject* managedInstance = value->getManagedInstance();
+					
+					if(managedInstance != nullptr)
+						return mono_object_unbox(managedInstance); // Structs are passed as raw types because mono expects them as such
+				}
+				else
+					return value->getManagedInstance();
+			}
+
+			return nullptr;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataArray::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoArray)
+		{
+			auto objectTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoArray>(typeInfo);
+
+			if(value != nullptr)
+				return value->getManagedInstance();
+
+			return nullptr;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataList::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoList)
+		{
+			auto listTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoList>(typeInfo);
+
+			if(value != nullptr)
+				return value->getManagedInstance();
+
+			return nullptr;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	void* ManagedSerializableFieldDataDictionary::getValue(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		if(typeInfo->getTypeId() == TID_SerializableTypeInfoDictionary)
+		{
+			auto dictionaryTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoDictionary>(typeInfo);
+
+			if(value != nullptr)
+				return value->getManagedInstance();
+
+			return nullptr;
+		}
+
+		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
+	}
+
+	RTTITypeBase* ManagedSerializableFieldKey::getRTTIStatic()
+	{
+		return ManagedSerializableFieldKeyRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldKey::getRTTI() const
+	{
+		return ManagedSerializableFieldKey::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldData::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldData::getRTTI() const
+	{
+		return ManagedSerializableFieldData::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataEntry::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataEntryRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataEntry::getRTTI() const
+	{
+		return ManagedSerializableFieldDataEntry::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataBool::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataBoolRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataBool::getRTTI() const
+	{
+		return ManagedSerializableFieldDataBool::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataChar::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataCharRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataChar::getRTTI() const
+	{
+		return ManagedSerializableFieldDataChar::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI8::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataI8RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI8::getRTTI() const
+	{
+		return ManagedSerializableFieldDataI8::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU8::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataU8RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU8::getRTTI() const
+	{
+		return ManagedSerializableFieldDataU8::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI16::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataI16RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI16::getRTTI() const
+	{
+		return ManagedSerializableFieldDataI16::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU16::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataU16RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU16::getRTTI() const
+	{
+		return ManagedSerializableFieldDataU16::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI32::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataI32RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI32::getRTTI() const
+	{
+		return ManagedSerializableFieldDataI32::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU32::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataU32RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU32::getRTTI() const
+	{
+		return ManagedSerializableFieldDataU32::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI64::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataI64RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataI64::getRTTI() const
+	{
+		return ManagedSerializableFieldDataI64::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU64::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataU64RTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataU64::getRTTI() const
+	{
+		return ManagedSerializableFieldDataU64::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataFloat::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataFloatRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataFloat::getRTTI() const
+	{
+		return ManagedSerializableFieldDataFloat::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataDouble::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataDoubleRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataDouble::getRTTI() const
+	{
+		return ManagedSerializableFieldDataDouble::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataString::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataStringRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataString::getRTTI() const
+	{
+		return ManagedSerializableFieldDataString::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataResourceRef::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataResourceRefRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataResourceRef::getRTTI() const
+	{
+		return ManagedSerializableFieldDataResourceRef::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataGameObjectRef::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataGameObjectRefRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataGameObjectRef::getRTTI() const
+	{
+		return ManagedSerializableFieldDataGameObjectRef::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataObject::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataObjectRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataObject::getRTTI() const
+	{
+		return ManagedSerializableFieldDataObject::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataArray::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataArrayRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataArray::getRTTI() const
+	{
+		return ManagedSerializableFieldDataArray::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataList::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataListRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataList::getRTTI() const
+	{
+		return ManagedSerializableFieldDataList::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataDictionary::getRTTIStatic()
+	{
+		return ManagedSerializableFieldDataDictionaryRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldDataDictionary::getRTTI() const
+	{
+		return ManagedSerializableFieldDataDictionary::getRTTIStatic();
+	}
+}

SBansheeEngine/Source/BsScriptSerializableList.cpp → SBansheeEngine/Source/BsManagedSerializableList.cpp

@@ -1,128 +1,128 @@
-#include "BsScriptSerializableList.h"
-#include "BsScriptSerializableListRTTI.h"
-#include "BsMonoManager.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsScriptSerializableField.h"
-#include "BsMonoClass.h"
-#include "BsMonoMethod.h"
-#include "BsMonoProperty.h"
-
-namespace BansheeEngine
-{
-	ScriptSerializableList::ScriptSerializableList(const ConstructPrivately& dummy)
-		:mManagedInstance(nullptr), mNumElements(0), mItemProp(nullptr), mCountProp(nullptr), mAddMethod(nullptr)
-	{
-
-	}
-
-	ScriptSerializableList::ScriptSerializableList(const ConstructPrivately& dummy, const ScriptSerializableTypeInfoListPtr& typeInfo, MonoObject* managedInstance)
-		:mListTypeInfo(typeInfo), mManagedInstance(managedInstance), mNumElements(0), mItemProp(nullptr),
-		mCountProp(nullptr), mAddMethod(nullptr)
-	{
-		MonoClass* listClass = MonoManager::instance().findClass(mono_object_get_class(managedInstance));
-		if(listClass == nullptr)
-			return;
-
-		initMonoObjects(listClass);
-
-		mNumElements = getLength();
-	}
-
-	ScriptSerializableListPtr ScriptSerializableList::create(MonoObject* managedInstance, const ScriptSerializableTypeInfoListPtr& typeInfo)
-	{
-		if(managedInstance == nullptr)
-			return nullptr;
-
-		::MonoClass* monoClass = mono_object_get_class(managedInstance);
-		String elementNs = mono_class_get_namespace(monoClass);
-		String elementTypeName = mono_class_get_name(monoClass);
-		String fullName = elementNs + "." + elementTypeName;
-
-		if(RuntimeScriptObjects::instance().getSystemGenericListClass()->getFullName() != fullName)
-			return nullptr;
-
-		return cm_shared_ptr<ScriptSerializableList>(ConstructPrivately(), typeInfo, managedInstance);
-	}
-
-	ScriptSerializableListPtr ScriptSerializableList::createEmpty()
-	{
-		return cm_shared_ptr<ScriptSerializableList>(ConstructPrivately());
-	}
-
-	void ScriptSerializableList::serializeManagedInstance()
-	{
-		mListEntries.resize(mNumElements);
-		for(UINT32 i = 0; i < mNumElements; i++)
-		{
-			mListEntries[i] = getFieldData(i);
-		}
-	}
-
-	void ScriptSerializableList::deserializeManagedInstance()
-	{
-		if(!mListTypeInfo->isTypeLoaded())
-			return;
-
-		::MonoClass* listMonoClass = mListTypeInfo->getMonoClass();
-		MonoClass* listClass = MonoManager::instance().findClass(listMonoClass);
-		if(listClass == nullptr)
-			return;
-
-		initMonoObjects(listClass);
-
-		void* params[1] = { &mNumElements };
-		mManagedInstance = listClass->createInstance("int", params);
-
-		for(auto& arrayEntry : mListEntries)
-		{
-			addFieldData(arrayEntry);
-		}
-	}
-
-	void ScriptSerializableList::setFieldData(UINT32 arrayIdx, const ScriptSerializableFieldDataPtr& val)
-	{
-		mItemProp->setIndexed(mManagedInstance, &arrayIdx, val->getValue(mListTypeInfo->mElementType));
-	}
-
-
-	void ScriptSerializableList::addFieldData(const ScriptSerializableFieldDataPtr& val)
-	{
-		void* params[1];
-		params[0] = val->getValue(mListTypeInfo->mElementType);
-		mAddMethod->invoke(mManagedInstance, params);
-	}
-
-	ScriptSerializableFieldDataPtr ScriptSerializableList::getFieldData(UINT32 arrayIdx)
-	{
-		MonoObject* obj = mItemProp->getIndexed(mManagedInstance, &arrayIdx);
-
-		return ScriptSerializableFieldData::create(mListTypeInfo->mElementType, obj);
-	}
-
-	UINT32 ScriptSerializableList::getLength() const
-	{
-		MonoObject* length = mCountProp->get(mManagedInstance);
-
-		if(length == nullptr)
-			return 0;
-
-		return *(UINT32*)mono_object_unbox(length);
-	}
-
-	void ScriptSerializableList::initMonoObjects(MonoClass* listClass)
-	{
-		mItemProp = &listClass->getProperty("Item");
-		mCountProp = &listClass->getProperty("Count");
-		mAddMethod = &listClass->getMethod("Add", 1);
-	}
-
-	RTTITypeBase* ScriptSerializableList::getRTTIStatic()
-	{
-		return ScriptSerializableListRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableList::getRTTI() const
-	{
-		return ScriptSerializableList::getRTTIStatic();
-	}
+#include "BsManagedSerializableList.h"
+#include "BsManagedSerializableListRTTI.h"
+#include "BsMonoManager.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsManagedSerializableField.h"
+#include "BsMonoClass.h"
+#include "BsMonoMethod.h"
+#include "BsMonoProperty.h"
+
+namespace BansheeEngine
+{
+	ManagedSerializableList::ManagedSerializableList(const ConstructPrivately& dummy)
+		:mManagedInstance(nullptr), mNumElements(0), mItemProp(nullptr), mCountProp(nullptr), mAddMethod(nullptr)
+	{
+
+	}
+
+	ManagedSerializableList::ManagedSerializableList(const ConstructPrivately& dummy, const ManagedSerializableTypeInfoListPtr& typeInfo, MonoObject* managedInstance)
+		:mListTypeInfo(typeInfo), mManagedInstance(managedInstance), mNumElements(0), mItemProp(nullptr),
+		mCountProp(nullptr), mAddMethod(nullptr)
+	{
+		MonoClass* listClass = MonoManager::instance().findClass(mono_object_get_class(managedInstance));
+		if(listClass == nullptr)
+			return;
+
+		initMonoObjects(listClass);
+
+		mNumElements = getLength();
+	}
+
+	ManagedSerializableListPtr ManagedSerializableList::create(MonoObject* managedInstance, const ManagedSerializableTypeInfoListPtr& typeInfo)
+	{
+		if(managedInstance == nullptr)
+			return nullptr;
+
+		::MonoClass* monoClass = mono_object_get_class(managedInstance);
+		String elementNs = mono_class_get_namespace(monoClass);
+		String elementTypeName = mono_class_get_name(monoClass);
+		String fullName = elementNs + "." + elementTypeName;
+
+		if(RuntimeScriptObjects::instance().getSystemGenericListClass()->getFullName() != fullName)
+			return nullptr;
+
+		return cm_shared_ptr<ManagedSerializableList>(ConstructPrivately(), typeInfo, managedInstance);
+	}
+
+	ManagedSerializableListPtr ManagedSerializableList::createEmpty()
+	{
+		return cm_shared_ptr<ManagedSerializableList>(ConstructPrivately());
+	}
+
+	void ManagedSerializableList::serializeManagedInstance()
+	{
+		mListEntries.resize(mNumElements);
+		for(UINT32 i = 0; i < mNumElements; i++)
+		{
+			mListEntries[i] = getFieldData(i);
+		}
+	}
+
+	void ManagedSerializableList::deserializeManagedInstance()
+	{
+		if(!mListTypeInfo->isTypeLoaded())
+			return;
+
+		::MonoClass* listMonoClass = mListTypeInfo->getMonoClass();
+		MonoClass* listClass = MonoManager::instance().findClass(listMonoClass);
+		if(listClass == nullptr)
+			return;
+
+		initMonoObjects(listClass);
+
+		void* params[1] = { &mNumElements };
+		mManagedInstance = listClass->createInstance("int", params);
+
+		for(auto& arrayEntry : mListEntries)
+		{
+			addFieldData(arrayEntry);
+		}
+	}
+
+	void ManagedSerializableList::setFieldData(UINT32 arrayIdx, const ManagedSerializableFieldDataPtr& val)
+	{
+		mItemProp->setIndexed(mManagedInstance, &arrayIdx, val->getValue(mListTypeInfo->mElementType));
+	}
+
+
+	void ManagedSerializableList::addFieldData(const ManagedSerializableFieldDataPtr& val)
+	{
+		void* params[1];
+		params[0] = val->getValue(mListTypeInfo->mElementType);
+		mAddMethod->invoke(mManagedInstance, params);
+	}
+
+	ManagedSerializableFieldDataPtr ManagedSerializableList::getFieldData(UINT32 arrayIdx)
+	{
+		MonoObject* obj = mItemProp->getIndexed(mManagedInstance, &arrayIdx);
+
+		return ManagedSerializableFieldData::create(mListTypeInfo->mElementType, obj);
+	}
+
+	UINT32 ManagedSerializableList::getLength() const
+	{
+		MonoObject* length = mCountProp->get(mManagedInstance);
+
+		if(length == nullptr)
+			return 0;
+
+		return *(UINT32*)mono_object_unbox(length);
+	}
+
+	void ManagedSerializableList::initMonoObjects(MonoClass* listClass)
+	{
+		mItemProp = &listClass->getProperty("Item");
+		mCountProp = &listClass->getProperty("Count");
+		mAddMethod = &listClass->getMethod("Add", 1);
+	}
+
+	RTTITypeBase* ManagedSerializableList::getRTTIStatic()
+	{
+		return ManagedSerializableListRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableList::getRTTI() const
+	{
+		return ManagedSerializableList::getRTTIStatic();
+	}
 }

SBansheeEngine/Source/BsScriptSerializableObject.cpp → SBansheeEngine/Source/BsManagedSerializableObject.cpp

@@ -1,185 +1,185 @@
-#include "BsScriptSerializableObject.h"
-#include "BsScriptSerializableObjectRTTI.h"
-#include "BsScriptSerializableObjectInfo.h"
-#include "BsScriptSerializableField.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsMonoField.h"
-
-namespace BansheeEngine
-{
-	ScriptSerializableObject::ScriptSerializableObject(const ConstructPrivately& dummy)
-		:mManagedInstance(nullptr)
-	{
-
-	}
-
-	ScriptSerializableObject::ScriptSerializableObject(const ConstructPrivately& dummy, ScriptSerializableObjectInfoPtr objInfo, MonoObject* managedInstance)
-		:mObjInfo(objInfo), mManagedInstance(managedInstance)
-	{
-
-	}
-
-	ScriptSerializableObjectPtr ScriptSerializableObject::create(MonoObject* managedInstance)
-	{
-		if(managedInstance == nullptr)
-			return nullptr;
-
-		::MonoClass* monoClass = mono_object_get_class(managedInstance);
-		String elementNs = mono_class_get_namespace(monoClass);
-		String elementTypeName = mono_class_get_name(monoClass);
-
-		ScriptSerializableObjectInfoPtr objInfo;
-		if(!RuntimeScriptObjects::instance().getSerializableObjectInfo(elementNs, elementTypeName, objInfo))
-			return nullptr;
-
-		return cm_shared_ptr<ScriptSerializableObject>(ConstructPrivately(), objInfo, managedInstance);
-	}
-
-	ScriptSerializableObjectPtr ScriptSerializableObject::createEmpty()
-	{
-		return cm_shared_ptr<ScriptSerializableObject>(ConstructPrivately());
-	}
-
-	void ScriptSerializableObject::serializeManagedInstance()
-	{
-		ScriptSerializableObjectInfoPtr curType = mObjInfo;
-
-		UINT32 numFields = 0;
-		while(curType != nullptr)
-		{
-			for(auto& field : mObjInfo->mFields)
-			{
-				if(field.second->isSerializable())
-					numFields++;
-			}
-			curType = curType->mBaseClass;
-		}
-
-		mFieldEntries.resize(numFields);
-		curType = mObjInfo;
-		UINT32 curIdx = 0;
-		while(curType != nullptr)
-		{
-			for(auto& field : mObjInfo->mFields)
-			{
-				if(!field.second->isSerializable())
-					continue;
-
-				ScriptSerializableFieldKeyPtr fieldKey = ScriptSerializableFieldKey::create(curType->mTypeId, field.second->mFieldId);
-				ScriptSerializableFieldDataPtr fieldData = getFieldData(field.second);
-
-				mFieldEntries[curIdx] = ScriptSerializableFieldDataEntry::create(fieldKey, fieldData);
-				curIdx++;
-			}
-
-			curType = curType->mBaseClass;
-		}
-	}
-
-	void ScriptSerializableObject::deserializeManagedInstance()
-	{
-		ScriptSerializableObjectInfoPtr storedObjInfo = mObjInfo;
-		ScriptSerializableObjectInfoPtr currentObjInfo = nullptr;
-
-		// See if this type even still exists
-		if(!RuntimeScriptObjects::instance().getSerializableObjectInfo(storedObjInfo->mTypeInfo->mTypeNamespace, storedObjInfo->mTypeInfo->mTypeName, currentObjInfo))
-			return;
-
-		if(storedObjInfo->mTypeInfo->mValueType)
-			mManagedInstance = currentObjInfo->mMonoClass->createInstance(false);
-		else
-			mManagedInstance = currentObjInfo->mMonoClass->createInstance();
-
-		auto findFieldInfoFromKey = [&] (UINT16 typeId, UINT16 fieldId, ScriptSerializableObjectInfoPtr objInfo, 
-			ScriptSerializableFieldInfoPtr& outFieldInfo, ScriptSerializableObjectInfoPtr &outObjInfo) -> bool
-		{
-			while(objInfo != nullptr)
-			{
-				if(objInfo->mTypeId == typeId)
-				{
-					auto iterFind = objInfo->mFields.find(fieldId);
-					if(iterFind != objInfo->mFields.end())
-					{
-						outFieldInfo = iterFind->second;
-						outObjInfo = objInfo;
-
-						return true;
-					}
-
-					return false;
-				}
-
-				objInfo = objInfo->mBaseClass;
-			}
-
-			return false;
-		};
-
-		auto findTypeNameMatchingFieldInfo = [&] (const ScriptSerializableFieldInfoPtr& fieldInfo, const ScriptSerializableObjectInfoPtr& fieldObjInfo, 
-			ScriptSerializableObjectInfoPtr objInfo) -> ScriptSerializableFieldInfoPtr
-		{
-			while(objInfo != nullptr)
-			{
-				if(objInfo->mTypeInfo->matches(fieldObjInfo->mTypeInfo))
-				{
-					auto iterFind = objInfo->mFieldNameToId.find(fieldInfo->mName);
-					if(iterFind != objInfo->mFieldNameToId.end())
-					{
-						auto iterFind2 = objInfo->mFields.find(iterFind->second);
-						if(iterFind2 != objInfo->mFields.end())
-						{
-							ScriptSerializableFieldInfoPtr foundField = iterFind2->second;
-							if(foundField->isSerializable())
-							{
-								if(fieldInfo->mTypeInfo->matches(foundField->mTypeInfo))
-									return foundField;
-							}
-						}
-					}
-
-					return nullptr;
-				}
-
-				objInfo = objInfo->mBaseClass;
-			}
-
-			return nullptr;
-		};
-
-		// Scan all fields and ensure the fields still exist
-		for(auto& fieldEntry : mFieldEntries)
-		{
-			ScriptSerializableFieldInfoPtr storedFieldEntry;
-			ScriptSerializableObjectInfoPtr storedFieldObjEntry;
-
-			if(!findFieldInfoFromKey(fieldEntry->mKey->mTypeId, fieldEntry->mKey->mFieldId, storedObjInfo, storedFieldEntry, storedFieldObjEntry))
-				continue;
-
-			ScriptSerializableFieldInfoPtr matchingFieldInfo = findTypeNameMatchingFieldInfo(storedFieldEntry, storedFieldObjEntry, currentObjInfo);
-			if(matchingFieldInfo != nullptr)
-				setFieldData(matchingFieldInfo, fieldEntry->mValue);
-		}
-	}
-
-	void ScriptSerializableObject::setFieldData(const ScriptSerializableFieldInfoPtr& fieldInfo, const ScriptSerializableFieldDataPtr& val)
-	{
-		fieldInfo->mMonoField->setValue(mManagedInstance, val->getValue(fieldInfo->mTypeInfo));
-	}
-
-	ScriptSerializableFieldDataPtr ScriptSerializableObject::getFieldData(const ScriptSerializableFieldInfoPtr& fieldInfo)
-	{
-		MonoObject* fieldValue = fieldInfo->mMonoField->getValueBoxed(mManagedInstance);
-
-		return ScriptSerializableFieldData::create(fieldInfo->mTypeInfo, fieldValue);		
-	}
-
-	RTTITypeBase* ScriptSerializableObject::getRTTIStatic()
-	{
-		return ScriptSerializableObjectRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableObject::getRTTI() const
-	{
-		return ScriptSerializableObject::getRTTIStatic();
-	}
+#include "BsManagedSerializableObject.h"
+#include "BsManagedSerializableObjectRTTI.h"
+#include "BsManagedSerializableObjectInfo.h"
+#include "BsManagedSerializableField.h"
+#include "BsRuntimeScriptObjects.h"
+#include "BsMonoField.h"
+
+namespace BansheeEngine
+{
+	ManagedSerializableObject::ManagedSerializableObject(const ConstructPrivately& dummy)
+		:mManagedInstance(nullptr)
+	{
+
+	}
+
+	ManagedSerializableObject::ManagedSerializableObject(const ConstructPrivately& dummy, ManagedSerializableObjectInfoPtr objInfo, MonoObject* managedInstance)
+		:mObjInfo(objInfo), mManagedInstance(managedInstance)
+	{
+
+	}
+
+	ManagedSerializableObjectPtr ManagedSerializableObject::create(MonoObject* managedInstance)
+	{
+		if(managedInstance == nullptr)
+			return nullptr;
+
+		::MonoClass* monoClass = mono_object_get_class(managedInstance);
+		String elementNs = mono_class_get_namespace(monoClass);
+		String elementTypeName = mono_class_get_name(monoClass);
+
+		ManagedSerializableObjectInfoPtr objInfo;
+		if(!RuntimeScriptObjects::instance().getSerializableObjectInfo(elementNs, elementTypeName, objInfo))
+			return nullptr;
+
+		return cm_shared_ptr<ManagedSerializableObject>(ConstructPrivately(), objInfo, managedInstance);
+	}
+
+	ManagedSerializableObjectPtr ManagedSerializableObject::createEmpty()
+	{
+		return cm_shared_ptr<ManagedSerializableObject>(ConstructPrivately());
+	}
+
+	void ManagedSerializableObject::serializeManagedInstance()
+	{
+		ManagedSerializableObjectInfoPtr curType = mObjInfo;
+
+		UINT32 numFields = 0;
+		while(curType != nullptr)
+		{
+			for(auto& field : mObjInfo->mFields)
+			{
+				if(field.second->isSerializable())
+					numFields++;
+			}
+			curType = curType->mBaseClass;
+		}
+
+		mFieldEntries.resize(numFields);
+		curType = mObjInfo;
+		UINT32 curIdx = 0;
+		while(curType != nullptr)
+		{
+			for(auto& field : mObjInfo->mFields)
+			{
+				if(!field.second->isSerializable())
+					continue;
+
+				ManagedSerializableFieldKeyPtr fieldKey = ManagedSerializableFieldKey::create(curType->mTypeId, field.second->mFieldId);
+				ManagedSerializableFieldDataPtr fieldData = getFieldData(field.second);
+
+				mFieldEntries[curIdx] = ManagedSerializableFieldDataEntry::create(fieldKey, fieldData);
+				curIdx++;
+			}
+
+			curType = curType->mBaseClass;
+		}
+	}
+
+	void ManagedSerializableObject::deserializeManagedInstance()
+	{
+		ManagedSerializableObjectInfoPtr storedObjInfo = mObjInfo;
+		ManagedSerializableObjectInfoPtr currentObjInfo = nullptr;
+
+		// See if this type even still exists
+		if(!RuntimeScriptObjects::instance().getSerializableObjectInfo(storedObjInfo->mTypeInfo->mTypeNamespace, storedObjInfo->mTypeInfo->mTypeName, currentObjInfo))
+			return;
+
+		if(storedObjInfo->mTypeInfo->mValueType)
+			mManagedInstance = currentObjInfo->mMonoClass->createInstance(false);
+		else
+			mManagedInstance = currentObjInfo->mMonoClass->createInstance();
+
+		auto findFieldInfoFromKey = [&] (UINT16 typeId, UINT16 fieldId, ManagedSerializableObjectInfoPtr objInfo, 
+			ManagedSerializableFieldInfoPtr& outFieldInfo, ManagedSerializableObjectInfoPtr &outObjInfo) -> bool
+		{
+			while(objInfo != nullptr)
+			{
+				if(objInfo->mTypeId == typeId)
+				{
+					auto iterFind = objInfo->mFields.find(fieldId);
+					if(iterFind != objInfo->mFields.end())
+					{
+						outFieldInfo = iterFind->second;
+						outObjInfo = objInfo;
+
+						return true;
+					}
+
+					return false;
+				}
+
+				objInfo = objInfo->mBaseClass;
+			}
+
+			return false;
+		};
+
+		auto findTypeNameMatchingFieldInfo = [&] (const ManagedSerializableFieldInfoPtr& fieldInfo, const ManagedSerializableObjectInfoPtr& fieldObjInfo, 
+			ManagedSerializableObjectInfoPtr objInfo) -> ManagedSerializableFieldInfoPtr
+		{
+			while(objInfo != nullptr)
+			{
+				if(objInfo->mTypeInfo->matches(fieldObjInfo->mTypeInfo))
+				{
+					auto iterFind = objInfo->mFieldNameToId.find(fieldInfo->mName);
+					if(iterFind != objInfo->mFieldNameToId.end())
+					{
+						auto iterFind2 = objInfo->mFields.find(iterFind->second);
+						if(iterFind2 != objInfo->mFields.end())
+						{
+							ManagedSerializableFieldInfoPtr foundField = iterFind2->second;
+							if(foundField->isSerializable())
+							{
+								if(fieldInfo->mTypeInfo->matches(foundField->mTypeInfo))
+									return foundField;
+							}
+						}
+					}
+
+					return nullptr;
+				}
+
+				objInfo = objInfo->mBaseClass;
+			}
+
+			return nullptr;
+		};
+
+		// Scan all fields and ensure the fields still exist
+		for(auto& fieldEntry : mFieldEntries)
+		{
+			ManagedSerializableFieldInfoPtr storedFieldEntry;
+			ManagedSerializableObjectInfoPtr storedFieldObjEntry;
+
+			if(!findFieldInfoFromKey(fieldEntry->mKey->mTypeId, fieldEntry->mKey->mFieldId, storedObjInfo, storedFieldEntry, storedFieldObjEntry))
+				continue;
+
+			ManagedSerializableFieldInfoPtr matchingFieldInfo = findTypeNameMatchingFieldInfo(storedFieldEntry, storedFieldObjEntry, currentObjInfo);
+			if(matchingFieldInfo != nullptr)
+				setFieldData(matchingFieldInfo, fieldEntry->mValue);
+		}
+	}
+
+	void ManagedSerializableObject::setFieldData(const ManagedSerializableFieldInfoPtr& fieldInfo, const ManagedSerializableFieldDataPtr& val)
+	{
+		fieldInfo->mMonoField->setValue(mManagedInstance, val->getValue(fieldInfo->mTypeInfo));
+	}
+
+	ManagedSerializableFieldDataPtr ManagedSerializableObject::getFieldData(const ManagedSerializableFieldInfoPtr& fieldInfo)
+	{
+		MonoObject* fieldValue = fieldInfo->mMonoField->getValueBoxed(mManagedInstance);
+
+		return ManagedSerializableFieldData::create(fieldInfo->mTypeInfo, fieldValue);		
+	}
+
+	RTTITypeBase* ManagedSerializableObject::getRTTIStatic()
+	{
+		return ManagedSerializableObjectRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableObject::getRTTI() const
+	{
+		return ManagedSerializableObject::getRTTIStatic();
+	}
 }

SBansheeEngine/Source/BsManagedSerializableObjectInfo.cpp

@@ -0,0 +1,280 @@
+#include "BsManagedSerializableObjectInfo.h"
+#include "BsManagedSerializableObjectInfoRTTI.h"
+#include "BsMonoUtil.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsScriptResourceManager.h"
+#include "BsScriptGameObjectManager.h"
+#include "BsScriptTexture2D.h"
+#include "BsScriptSpriteTexture.h"
+#include "BsScriptComponent.h"
+#include "BsScriptSceneObject.h"
+#include "BsManagedSerializableObjectInfo.h"
+#include "BsRuntimeScriptObjects.h"
+
+namespace BansheeEngine
+{
+	RTTITypeBase* ManagedSerializableAssemblyInfo::getRTTIStatic()
+	{
+		return ManagedSerializableAssemblyInfoRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableAssemblyInfo::getRTTI() const
+	{
+		return ManagedSerializableAssemblyInfo::getRTTIStatic();
+	}
+
+	ManagedSerializableObjectInfo::ManagedSerializableObjectInfo()
+		:mMonoClass(nullptr), mTypeId(0)
+	{
+
+	}
+
+	RTTITypeBase* ManagedSerializableObjectInfo::getRTTIStatic()
+	{
+		return ManagedSerializableObjectInfoRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableObjectInfo::getRTTI() const
+	{
+		return ManagedSerializableObjectInfo::getRTTIStatic();
+	}
+
+	ManagedSerializableFieldInfo::ManagedSerializableFieldInfo()
+		:mMonoField(nullptr), mFlags((ScriptFieldFlags)0), mFieldId(0)
+	{
+
+	}
+
+	RTTITypeBase* ManagedSerializableFieldInfo::getRTTIStatic()
+	{
+		return ManagedSerializableFieldInfoRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableFieldInfo::getRTTI() const
+	{
+		return ManagedSerializableFieldInfo::getRTTIStatic();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfo::getRTTIStatic()
+	{
+		return ManagedSerializableTypeInfoRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfo::getRTTI() const
+	{
+		return ManagedSerializableTypeInfo::getRTTIStatic();
+	}
+
+	bool ManagedSerializableTypeInfoPrimitive::matches(const ManagedSerializableTypeInfoPtr& typeInfo) const
+	{
+		if(!rtti_is_of_type<ManagedSerializableTypeInfoPrimitive>(typeInfo))
+			return false;
+
+		auto primTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
+
+		return primTypeInfo->mType == mType;
+	}
+
+	bool ManagedSerializableTypeInfoPrimitive::isTypeLoaded() const
+	{
+		return true;
+	}
+
+	::MonoClass* ManagedSerializableTypeInfoPrimitive::getMonoClass() const
+	{
+		switch(mType)
+		{
+		case ScriptPrimitiveType::Bool:
+			return mono_get_boolean_class();
+		case ScriptPrimitiveType::Char:
+			return mono_get_char_class();
+		case ScriptPrimitiveType::I8:
+			return mono_get_sbyte_class();
+		case ScriptPrimitiveType::U8:
+			return mono_get_byte_class();
+		case ScriptPrimitiveType::I16:
+			return mono_get_int16_class();
+		case ScriptPrimitiveType::U16:
+			return mono_get_uint16_class();
+		case ScriptPrimitiveType::I32:
+			return mono_get_int32_class();
+		case ScriptPrimitiveType::U32:
+			return mono_get_uint32_class();
+		case ScriptPrimitiveType::I64:
+			return mono_get_int64_class();
+		case ScriptPrimitiveType::U64:
+			return mono_get_uint64_class();
+		case ScriptPrimitiveType::Float:
+			return mono_get_single_class();
+		case ScriptPrimitiveType::Double:
+			return mono_get_double_class();
+		case ScriptPrimitiveType::String:
+			return mono_get_string_class();
+		case ScriptPrimitiveType::TextureRef:
+			return RuntimeScriptObjects::instance().getTextureClass()->_getInternalClass();
+		case ScriptPrimitiveType::SpriteTextureRef:
+			return RuntimeScriptObjects::instance().getSpriteTextureClass()->_getInternalClass();
+		case ScriptPrimitiveType::SceneObjectRef:
+			return RuntimeScriptObjects::instance().getSceneObjectClass()->_getInternalClass();
+		case ScriptPrimitiveType::ComponentRef:
+			return RuntimeScriptObjects::instance().getComponentClass()->_getInternalClass();
+		}
+
+		return nullptr;
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoPrimitive::getRTTIStatic()
+	{
+		return ManagedSerializableTypeInfoPrimitiveRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoPrimitive::getRTTI() const
+	{
+		return ManagedSerializableTypeInfoPrimitive::getRTTIStatic();
+	}
+
+	bool ManagedSerializableTypeInfoObject::matches(const ManagedSerializableTypeInfoPtr& typeInfo) const
+	{
+		if(!rtti_is_of_type<ManagedSerializableTypeInfoObject>(typeInfo))
+			return false;
+
+		auto objTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoObject>(typeInfo);
+
+		return objTypeInfo->mTypeNamespace == mTypeNamespace && objTypeInfo->mTypeName == mTypeName && objTypeInfo->mValueType == mValueType;
+	}
+
+	bool ManagedSerializableTypeInfoObject::isTypeLoaded() const
+	{
+		return RuntimeScriptObjects::instance().hasSerializableObjectInfo(mTypeNamespace, mTypeName);
+	}
+
+	::MonoClass* ManagedSerializableTypeInfoObject::getMonoClass() const
+	{
+		ManagedSerializableObjectInfoPtr objInfo;
+		if(!RuntimeScriptObjects::instance().getSerializableObjectInfo(mTypeNamespace, mTypeName, objInfo))
+			return nullptr;
+
+		return objInfo->mMonoClass->_getInternalClass();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoObject::getRTTIStatic()
+	{
+		return ManagedSerializableTypeInfoObjectRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoObject::getRTTI() const
+	{
+		return ManagedSerializableTypeInfoObject::getRTTIStatic();
+	}
+
+	bool ManagedSerializableTypeInfoArray::matches(const ManagedSerializableTypeInfoPtr& typeInfo) const
+	{
+		if(!rtti_is_of_type<ManagedSerializableTypeInfoArray>(typeInfo))
+			return false;
+
+		auto arrayTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoArray>(typeInfo);
+
+		return arrayTypeInfo->mRank == mRank && arrayTypeInfo->mElementType->matches(mElementType);
+	}
+
+	bool ManagedSerializableTypeInfoArray::isTypeLoaded() const
+	{
+		return mElementType->isTypeLoaded();
+	}
+
+	::MonoClass* ManagedSerializableTypeInfoArray::getMonoClass() const
+	{
+		::MonoClass* elementClass = mElementType->getMonoClass();
+		if(elementClass == nullptr)
+			return nullptr;
+
+		return mono_array_class_get(mElementType->getMonoClass(), mRank);
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoArray::getRTTIStatic()
+	{
+		return ManagedSerializableTypeInfoArrayRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoArray::getRTTI() const
+	{
+		return ManagedSerializableTypeInfoArray::getRTTIStatic();
+	}
+
+	bool ManagedSerializableTypeInfoList::matches(const ManagedSerializableTypeInfoPtr& typeInfo) const
+	{
+		if(!rtti_is_of_type<ManagedSerializableTypeInfoList>(typeInfo))
+			return false;
+
+		auto listTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoList>(typeInfo);
+
+		return listTypeInfo->mElementType->matches(mElementType);
+	}
+
+	bool ManagedSerializableTypeInfoList::isTypeLoaded() const
+	{
+		return mElementType->isTypeLoaded();
+	}
+
+	::MonoClass* ManagedSerializableTypeInfoList::getMonoClass() const
+	{
+		::MonoClass* elementClass = mElementType->getMonoClass();
+		if(elementClass == nullptr)
+			return nullptr;
+
+		MonoClass* genericListClass = RuntimeScriptObjects::instance().getSystemGenericListClass();
+		MonoType* genParams[1] = { mono_class_get_type(elementClass) };
+
+		return mono_class_bind_generic_parameters(genericListClass->_getInternalClass(), 1, genParams, false);
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoList::getRTTIStatic()
+	{
+		return ManagedSerializableTypeInfoListRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoList::getRTTI() const
+	{
+		return ManagedSerializableTypeInfoList::getRTTIStatic();
+	}
+
+	bool ManagedSerializableTypeInfoDictionary::matches(const ManagedSerializableTypeInfoPtr& typeInfo) const
+	{
+		if(!rtti_is_of_type<ManagedSerializableTypeInfoDictionary>(typeInfo))
+			return false;
+
+		auto dictTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoDictionary>(typeInfo);
+
+		return dictTypeInfo->mKeyType->matches(mKeyType) && dictTypeInfo->mValueType->matches(mValueType);
+	}
+
+	bool ManagedSerializableTypeInfoDictionary::isTypeLoaded() const
+	{
+		return mKeyType->isTypeLoaded() && mValueType->isTypeLoaded();
+	}
+
+	::MonoClass* ManagedSerializableTypeInfoDictionary::getMonoClass() const
+	{
+		::MonoClass* keyClass = mKeyType->getMonoClass();
+		::MonoClass* valueClass = mValueType->getMonoClass();
+		if(keyClass == nullptr || valueClass == nullptr)
+			return nullptr;
+
+		MonoClass* genericDictionaryClass = RuntimeScriptObjects::instance().getSystemGenericDictionaryClass();
+		MonoType* genParams[2] = { mono_class_get_type(keyClass), mono_class_get_type(valueClass) };
+
+		return mono_class_bind_generic_parameters(genericDictionaryClass->_getInternalClass(), 2, genParams, false);
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoDictionary::getRTTIStatic()
+	{
+		return ManagedSerializableTypeInfoDictionaryRTTI::instance();
+	}
+
+	RTTITypeBase* ManagedSerializableTypeInfoDictionary::getRTTI() const
+	{
+		return ManagedSerializableTypeInfoDictionary::getRTTIStatic();
+	}
+}

SBansheeEngine/Source/BsRuntimeScriptObjects.cpp

@@ -1,7 +1,7 @@
 #include "BsRuntimeScriptObjects.h"
 #include "BsScriptResourceManager.h"
 #include "BsScriptGameObjectManager.h"
-#include "BsScriptSerializableObjectInfo.h"
+#include "BsManagedSerializableObjectInfo.h"
 #include "BsMonoManager.h"
 #include "BsMonoAssembly.h"
 #include "BsMonoClass.h"
@@ -14,7 +14,7 @@
 namespace BansheeEngine
 {
 	RuntimeScriptObjects::RuntimeScriptObjects()
-		:mBaseTypesInitialized(false), mSerializableObjectAttribute(nullptr), mDontSerializeFieldAttribute(nullptr), 
+		:mBaseTypesInitialized(false), mSerializeObjectAttribute(nullptr), mDontSerializeFieldAttribute(nullptr), 
 		mComponentClass(nullptr), mSceneObjectClass(nullptr), mTextureClass(nullptr), mSpriteTextureClass(nullptr),
 		mSerializeFieldAttribute(nullptr), mHideInInspectorAttribute(nullptr), mSystemArrayClass(nullptr), mSystemGenericListClass(nullptr),
 		mSystemGenericDictionaryClass(nullptr)
@@ -41,7 +41,7 @@ namespace BansheeEngine
 		if(curAssembly == nullptr)
 			return;
 
-		std::shared_ptr<ScriptSerializableAssemblyInfo> assemblyInfo = cm_shared_ptr<ScriptSerializableAssemblyInfo>();
+		std::shared_ptr<ManagedSerializableAssemblyInfo> assemblyInfo = cm_shared_ptr<ManagedSerializableAssemblyInfo>();
 		assemblyInfo->mName = assemblyName;
 
 		mAssemblyInfos[assemblyName] = assemblyInfo;
@@ -50,9 +50,9 @@ namespace BansheeEngine
 		const Vector<MonoClass*>::type& allClasses = curAssembly->getAllClasses();
 		for(auto& curClass : allClasses)
 		{
-			if((curClass->isSubClassOf(mComponentClass) || curClass->hasAttribute(mSerializableObjectAttribute)) && curClass != mComponentClass)
+			if((curClass->isSubClassOf(mComponentClass) || curClass->hasAttribute(mSerializeObjectAttribute)) && curClass != mComponentClass)
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoObject> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoObject>();
+				std::shared_ptr<ManagedSerializableTypeInfoObject> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoObject>();
 				typeInfo->mTypeNamespace = curClass->getNamespace();
 				typeInfo->mTypeName = curClass->getTypeName();
 
@@ -64,7 +64,7 @@ namespace BansheeEngine
 				else
 					typeInfo->mValueType = false;
 
-				std::shared_ptr<ScriptSerializableObjectInfo> objInfo = cm_shared_ptr<ScriptSerializableObjectInfo>();
+				std::shared_ptr<ManagedSerializableObjectInfo> objInfo = cm_shared_ptr<ManagedSerializableObjectInfo>();
 
 				objInfo->mTypeId = mUniqueTypeId++;
 
@@ -79,7 +79,7 @@ namespace BansheeEngine
 		// Populate field data
 		for(auto& curClassInfo : assemblyInfo->mObjectInfos)
 		{
-			std::shared_ptr<ScriptSerializableObjectInfo> objInfo = curClassInfo.second;
+			std::shared_ptr<ManagedSerializableObjectInfo> objInfo = curClassInfo.second;
 
 			String fullTypeName = objInfo->getFullTypeName();
 			assemblyInfo->mTypeNameToId[fullTypeName] = objInfo->mTypeId;
@@ -93,7 +93,7 @@ namespace BansheeEngine
 				if(field->isStatic())
 					continue;
 
-				std::shared_ptr<ScriptSerializableFieldInfo> fieldInfo = cm_shared_ptr<ScriptSerializableFieldInfo>();
+				std::shared_ptr<ManagedSerializableFieldInfo> fieldInfo = cm_shared_ptr<ManagedSerializableFieldInfo>();
 
 				fieldInfo->mFieldId = mUniqueFieldId++;
 				fieldInfo->mName = field->getName();
@@ -129,7 +129,7 @@ namespace BansheeEngine
 			MonoClass* base = curClass.second->mMonoClass->getBaseClass();
 			while(base != nullptr)
 			{
-				std::shared_ptr<ScriptSerializableObjectInfo> baseObjInfo;
+				std::shared_ptr<ManagedSerializableObjectInfo> baseObjInfo;
 				if(getSerializableObjectInfo(base->getNamespace(), base->getTypeName(), baseObjInfo))
 				{
 					curClass.second->mBaseClass = baseObjInfo;
@@ -143,7 +143,7 @@ namespace BansheeEngine
 		}
 	}
 
-	ScriptSerializableTypeInfoPtr RuntimeScriptObjects::determineType(MonoClass* monoClass)
+	ManagedSerializableTypeInfoPtr RuntimeScriptObjects::determineType(MonoClass* monoClass)
 	{
 		if(!mBaseTypesInitialized)
 			CM_EXCEPT(InvalidStateException, "Calling determineType without previously initializing base types.");
@@ -156,104 +156,104 @@ namespace BansheeEngine
 		{
 		case MONO_TYPE_BOOLEAN:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Bool;
 				return typeInfo;
 			}
 		case MONO_TYPE_CHAR:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Char;
 				return typeInfo;
 			}
 		case MONO_TYPE_I1:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I8;
 				return typeInfo;
 			}
 		case MONO_TYPE_U1:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U8;
 				return typeInfo;
 			}
 		case MONO_TYPE_I2:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I16;
 				return typeInfo;
 			}
 		case MONO_TYPE_U2:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U16;
 				return typeInfo;
 			}
 		case MONO_TYPE_I4:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I32;
 				return typeInfo;
 			}
 		case MONO_TYPE_U4:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U32;
 				return typeInfo;
 			}
 		case MONO_TYPE_I8:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I64;
 				return typeInfo;
 			}
 		case MONO_TYPE_U8:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U64;
 				return typeInfo;
 			}
 		case MONO_TYPE_STRING:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::String;
 				return typeInfo;
 			}
 		case MONO_TYPE_R4:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Float;
 				return typeInfo;
 			}
 		case MONO_TYPE_R8:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Double;
 				return typeInfo;
 			}
 		case MONO_TYPE_CLASS:
 			if(monoClass->isSubClassOf(mTextureClass))
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::TextureRef;
 				return typeInfo;
 			}
 			else if(monoClass->isSubClassOf(mSpriteTextureClass))
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::SpriteTextureRef;
 				return typeInfo;
 			}
 			else if(monoClass->isSubClassOf(mSceneObjectClass))
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::SceneObjectRef;
 				return typeInfo;
 			}
 			else if(monoClass->isSubClassOf(mComponentClass))
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoPrimitive>();
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::ComponentRef;
 				return typeInfo;
 			}
@@ -261,7 +261,7 @@ namespace BansheeEngine
 			{
 				if(hasSerializableObjectInfo(monoClass->getNamespace(), monoClass->getTypeName()))
 				{
-					std::shared_ptr<ScriptSerializableTypeInfoObject> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoObject>();
+					std::shared_ptr<ManagedSerializableTypeInfoObject> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoObject>();
 					typeInfo->mTypeNamespace = monoClass->getNamespace();
 					typeInfo->mTypeName = monoClass->getTypeName();
 					typeInfo->mValueType = false;
@@ -274,7 +274,7 @@ namespace BansheeEngine
 		case MONO_TYPE_VALUETYPE:
 			if(hasSerializableObjectInfo(monoClass->getNamespace(), monoClass->getTypeName()))
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoObject> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoObject>();
+				std::shared_ptr<ManagedSerializableTypeInfoObject> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoObject>();
 				typeInfo->mTypeNamespace = monoClass->getNamespace();
 				typeInfo->mTypeName = monoClass->getTypeName();
 				typeInfo->mValueType = true;
@@ -286,7 +286,7 @@ namespace BansheeEngine
 		case MONO_TYPE_GENERICINST:
 			if(monoClass->getFullName() == mSystemGenericListClass->getFullName()) // Full name is part of CIL spec, so it is just fine to compare like this
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoList> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoList>();
+				std::shared_ptr<ManagedSerializableTypeInfoList> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoList>();
 
 				MonoProperty& itemProperty = monoClass->getProperty("Item");
 				MonoClass* itemClass = itemProperty.getReturnType();
@@ -298,7 +298,7 @@ namespace BansheeEngine
 			}
 			else if(monoClass->getFullName() == mSystemGenericDictionaryClass->getFullName())
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoDictionary> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoDictionary>();
+				std::shared_ptr<ManagedSerializableTypeInfoDictionary> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoDictionary>();
 
 				MonoMethod& getEnumerator = monoClass->getMethod("GetEnumerator");
 				MonoClass* enumClass = getEnumerator.getReturnType();
@@ -323,7 +323,7 @@ namespace BansheeEngine
 		case MONO_TYPE_SZARRAY:
 		case MONO_TYPE_ARRAY:
 			{
-				std::shared_ptr<ScriptSerializableTypeInfoArray> typeInfo = cm_shared_ptr<ScriptSerializableTypeInfoArray>();
+				std::shared_ptr<ManagedSerializableTypeInfoArray> typeInfo = cm_shared_ptr<ManagedSerializableTypeInfoArray>();
 
 				::MonoClass* elementClass = mono_class_get_element_class(monoClass->_getInternalClass());
 				if(elementClass != nullptr)
@@ -352,7 +352,7 @@ namespace BansheeEngine
 		mSystemGenericListClass = nullptr;
 		mSystemGenericDictionaryClass = nullptr;
 
-		mSerializableObjectAttribute = nullptr;
+		mSerializeObjectAttribute = nullptr;
 		mDontSerializeFieldAttribute = nullptr;
 
 		mComponentClass = nullptr;
@@ -388,8 +388,8 @@ namespace BansheeEngine
 		if(mSystemGenericDictionaryClass == nullptr)
 			CM_EXCEPT(InvalidStateException, "Cannot find Dictionary<TKey, TValue> managed class.");
 
-		mSerializableObjectAttribute = bansheeEngineAssembly->getClass("BansheeEngine", "SerializableObject");
-		if(mSerializableObjectAttribute == nullptr)
+		mSerializeObjectAttribute = bansheeEngineAssembly->getClass("BansheeEngine", "SerializeObject");
+		if(mSerializeObjectAttribute == nullptr)
 			CM_EXCEPT(InvalidStateException, "Cannot find SerializableObject managed class.");
 
 		mDontSerializeFieldAttribute = bansheeEngineAssembly->getClass("BansheeEngine", "DontSerializeField");
@@ -423,7 +423,7 @@ namespace BansheeEngine
 		mBaseTypesInitialized = true;
 	}
 
-	bool RuntimeScriptObjects::getSerializableObjectInfo(const String& ns, const String& typeName, std::shared_ptr<ScriptSerializableObjectInfo>& outInfo)
+	bool RuntimeScriptObjects::getSerializableObjectInfo(const String& ns, const String& typeName, std::shared_ptr<ManagedSerializableObjectInfo>& outInfo)
 	{
 		String fullName = ns + "." + typeName;
 		for(auto& curAssembly : mAssemblyInfos)

SBansheeEngine/Source/BsScriptSerializableField.cpp

@@ -1,754 +0,0 @@
-#include "BsScriptSerializableField.h"
-#include "BsScriptSerializableObjectInfo.h"
-#include "BsScriptSerializableFieldRTTI.h"
-#include "BsMonoUtil.h"
-#include "BsMonoManager.h"
-#include "BsScriptResourceManager.h"
-#include "BsScriptGameObjectManager.h"
-#include "BsScriptTexture2D.h"
-#include "BsScriptSpriteTexture.h"
-#include "BsScriptSceneObject.h"
-#include "BsScriptComponent.h"
-#include "BsScriptSerializableObject.h"
-#include "BsScriptSerializableArray.h"
-#include "BsScriptSerializableList.h"
-#include "BsScriptSerializableDictionary.h"
-
-namespace BansheeEngine
-{
-	ScriptSerializableFieldKeyPtr ScriptSerializableFieldKey::create(UINT16 typeId, UINT16 fieldId)
-	{
-		ScriptSerializableFieldKeyPtr fieldKey = cm_shared_ptr<ScriptSerializableFieldKey>();
-		fieldKey->mTypeId = typeId;
-		fieldKey->mFieldId = fieldId;
-
-		return fieldKey;
-	}
-
-	ScriptSerializableFieldDataEntryPtr ScriptSerializableFieldDataEntry::create(const ScriptSerializableFieldKeyPtr& key, const ScriptSerializableFieldDataPtr& value)
-	{
-		ScriptSerializableFieldDataEntryPtr fieldDataEntry = cm_shared_ptr<ScriptSerializableFieldDataEntry>();
-		fieldDataEntry->mKey = key;
-		fieldDataEntry->mValue = value;
-
-		return fieldDataEntry;
-	}
-
-	ScriptSerializableFieldDataPtr ScriptSerializableFieldData::create(const ScriptSerializableTypeInfoPtr& typeInfo, MonoObject* value)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			switch (primitiveTypeInfo->mType)
-			{
-			case ScriptPrimitiveType::Bool:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataBool>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-
-					return fieldData;
-				}
-			case ScriptPrimitiveType::Char:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataChar>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::I8:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataI8>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::U8:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataU8>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::I16:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataI16>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::U16:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataU16>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::I32:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataI32>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::U32:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataU32>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::I64:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataI64>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::U64:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataU64>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::Float:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataFloat>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::Double:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataDouble>();
-					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
-					return fieldData;
-				}
-			case ScriptPrimitiveType::String:
-				{
-					MonoString* strVal = (MonoString*)(value);
-
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataString>();
-					if(strVal != nullptr)
-						fieldData->value = MonoUtil::monoToWString(strVal);
-					return fieldData;
-				}
-			case ScriptPrimitiveType::TextureRef:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataResourceRef>();
-
-					if(value != nullptr)
-					{
-						ScriptTexture2D* scriptTexture2D = ScriptTexture2D::toNative(value);
-						fieldData->value = static_resource_cast<ScriptTexture2D>(scriptTexture2D->getNativeHandle());
-					}
-
-					return fieldData;
-				}
-			case ScriptPrimitiveType::SpriteTextureRef:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataResourceRef>();
-					
-					if(value != nullptr)
-					{
-						ScriptSpriteTexture* scriptSpriteTexture = ScriptSpriteTexture::toNative(value);
-						fieldData->value = static_resource_cast<SpriteTexture>(scriptSpriteTexture->getNativeHandle());
-					}
-
-					return fieldData;
-				}
-			case ScriptPrimitiveType::SceneObjectRef:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataGameObjectRef>();
-
-					if(value != nullptr)
-					{
-						ScriptSceneObject* scriptSceneObject = ScriptSceneObject::toNative(value);
-						fieldData->value = static_object_cast<SceneObject>(scriptSceneObject->getNativeHandle());
-					}
-
-					return fieldData;
-				}
-			case ScriptPrimitiveType::ComponentRef:
-				{
-					auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataGameObjectRef>();
-
-					if(value != nullptr)
-					{
-						ScriptComponent* scriptComponent = ScriptComponent::toNative(value);
-						fieldData->value = static_object_cast<Component>(scriptComponent->getNativeHandle());
-					}
-
-					return fieldData;
-				}
-			}
-		}
-		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoObject)
-		{
-			auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataObject>();
-			if(value != nullptr)
-			{
-				fieldData->value = ScriptSerializableObject::create(value);
-			}
-
-			return fieldData;
-		}
-		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoArray)
-		{
-			auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataArray>();
-			if(value != nullptr)
-			{
-				fieldData->value = ScriptSerializableArray::create(value, std::static_pointer_cast<ScriptSerializableTypeInfoArray>(typeInfo));
-			}
-
-			return fieldData;
-		}
-		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoList)
-		{
-			auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataList>();
-			if(value != nullptr)
-			{
-				fieldData->value = ScriptSerializableList::create(value, std::static_pointer_cast<ScriptSerializableTypeInfoList>(typeInfo));
-			}
-
-			return fieldData;
-		}
-		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoDictionary)
-		{
-			auto fieldData = cm_shared_ptr<ScriptSerializableFieldDataDictionary>();
-			if(value != nullptr)
-			{
-				fieldData->value = ScriptSerializableDictionary::create(value, std::static_pointer_cast<ScriptSerializableTypeInfoDictionary>(typeInfo));
-			}
-
-			return fieldData;
-		}
-
-		return nullptr;
-	}
-
-	void* ScriptSerializableFieldDataBool::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Bool)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataChar::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Char)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataI8::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I8)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataU8::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U8)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataI16::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I16)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataU16::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U16)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataI32::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I32)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataU32::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U32)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataI64::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::I64)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataU64::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::U64)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataFloat::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Float)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataDouble::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Double)
-				return &value;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataString::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::String)
-			{
-				return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), value);
-			}
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataResourceRef::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::TextureRef)
-			{
-				if(value)
-				{
-					ScriptTexture2D* scriptResource = ScriptResourceManager::instance().getScriptTexture(value);
-					if(scriptResource == nullptr)
-						scriptResource = ScriptResourceManager::instance().createScriptTexture(value);
-
-					return scriptResource->getManagedInstance();
-				}
-				else
-					return nullptr;
-			}
-			else if(primitiveTypeInfo->mType == ScriptPrimitiveType::SpriteTextureRef)
-			{
-				if(value)
-				{
-					ScriptSpriteTexture* scriptResource = ScriptResourceManager::instance().getScriptSpriteTexture(value);
-					if(scriptResource == nullptr)
-						scriptResource = ScriptResourceManager::instance().createScriptSpriteTexture(value);
-
-					if(scriptResource != nullptr)
-						return scriptResource->getManagedInstance();
-				}
-				else
-					return nullptr;
-			}
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataGameObjectRef::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
-		{
-			auto primitiveTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-
-			if(primitiveTypeInfo->mType == ScriptPrimitiveType::SceneObjectRef)
-			{
-				if(value)
-				{
-					ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getScriptSceneObject(value);
-					if(scriptSceneObject == nullptr)
-						scriptSceneObject = ScriptGameObjectManager::instance().createScriptSceneObject(value);
-
-					return scriptSceneObject->getManagedInstance();
-				}
-				else
-					return nullptr;
-			}
-			else if(primitiveTypeInfo->mType == ScriptPrimitiveType::ComponentRef)
-			{
-				if(value)
-				{
-					ScriptComponent* scriptComponent = ScriptGameObjectManager::instance().getScriptComponent(value);
-					if(scriptComponent == nullptr)
-						scriptComponent = ScriptGameObjectManager::instance().createScriptComponent(value);
-
-					return scriptComponent->getManagedInstance();
-				}
-				else
-					return nullptr;
-			}
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataObject::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoObject)
-		{
-			auto objectTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoObject>(typeInfo);
-
-			if(value != nullptr)
-			{
-				if(objectTypeInfo->mValueType)
-				{
-					MonoObject* managedInstance = value->getManagedInstance();
-					
-					if(managedInstance != nullptr)
-						return mono_object_unbox(managedInstance); // Structs are passed as raw types because mono expects them as such
-				}
-				else
-					return value->getManagedInstance();
-			}
-
-			return nullptr;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataArray::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoArray)
-		{
-			auto objectTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoArray>(typeInfo);
-
-			if(value != nullptr)
-				return value->getManagedInstance();
-
-			return nullptr;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataList::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoList)
-		{
-			auto listTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoList>(typeInfo);
-
-			if(value != nullptr)
-				return value->getManagedInstance();
-
-			return nullptr;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	void* ScriptSerializableFieldDataDictionary::getValue(const ScriptSerializableTypeInfoPtr& typeInfo)
-	{
-		if(typeInfo->getTypeId() == TID_SerializableTypeInfoDictionary)
-		{
-			auto dictionaryTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoDictionary>(typeInfo);
-
-			if(value != nullptr)
-				return value->getManagedInstance();
-
-			return nullptr;
-		}
-
-		CM_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
-	}
-
-	RTTITypeBase* ScriptSerializableFieldKey::getRTTIStatic()
-	{
-		return ScriptSerializableFieldKeyRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldKey::getRTTI() const
-	{
-		return ScriptSerializableFieldKey::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldData::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldData::getRTTI() const
-	{
-		return ScriptSerializableFieldData::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataEntry::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataEntryRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataEntry::getRTTI() const
-	{
-		return ScriptSerializableFieldDataEntry::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataBool::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataBoolRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataBool::getRTTI() const
-	{
-		return ScriptSerializableFieldDataBool::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataChar::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataCharRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataChar::getRTTI() const
-	{
-		return ScriptSerializableFieldDataChar::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI8::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataI8RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI8::getRTTI() const
-	{
-		return ScriptSerializableFieldDataI8::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU8::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataU8RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU8::getRTTI() const
-	{
-		return ScriptSerializableFieldDataU8::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI16::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataI16RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI16::getRTTI() const
-	{
-		return ScriptSerializableFieldDataI16::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU16::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataU16RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU16::getRTTI() const
-	{
-		return ScriptSerializableFieldDataU16::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI32::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataI32RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI32::getRTTI() const
-	{
-		return ScriptSerializableFieldDataI32::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU32::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataU32RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU32::getRTTI() const
-	{
-		return ScriptSerializableFieldDataU32::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI64::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataI64RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataI64::getRTTI() const
-	{
-		return ScriptSerializableFieldDataI64::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU64::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataU64RTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataU64::getRTTI() const
-	{
-		return ScriptSerializableFieldDataU64::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataFloat::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataFloatRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataFloat::getRTTI() const
-	{
-		return ScriptSerializableFieldDataFloat::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataDouble::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataDoubleRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataDouble::getRTTI() const
-	{
-		return ScriptSerializableFieldDataDouble::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataString::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataStringRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataString::getRTTI() const
-	{
-		return ScriptSerializableFieldDataString::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataResourceRef::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataResourceRefRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataResourceRef::getRTTI() const
-	{
-		return ScriptSerializableFieldDataResourceRef::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataGameObjectRef::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataGameObjectRefRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataGameObjectRef::getRTTI() const
-	{
-		return ScriptSerializableFieldDataGameObjectRef::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataObject::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataObjectRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataObject::getRTTI() const
-	{
-		return ScriptSerializableFieldDataObject::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataArray::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataArrayRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataArray::getRTTI() const
-	{
-		return ScriptSerializableFieldDataArray::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataList::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataListRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataList::getRTTI() const
-	{
-		return ScriptSerializableFieldDataList::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataDictionary::getRTTIStatic()
-	{
-		return ScriptSerializableFieldDataDictionaryRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldDataDictionary::getRTTI() const
-	{
-		return ScriptSerializableFieldDataDictionary::getRTTIStatic();
-	}
-}

SBansheeEngine/Source/BsScriptSerializableObjectInfo.cpp

@@ -1,280 +0,0 @@
-#include "BsScriptSerializableObjectInfo.h"
-#include "BsScriptSerializableObjectInfoRTTI.h"
-#include "BsMonoUtil.h"
-#include "BsMonoField.h"
-#include "BsMonoClass.h"
-#include "BsMonoManager.h"
-#include "BsScriptResourceManager.h"
-#include "BsScriptGameObjectManager.h"
-#include "BsScriptTexture2D.h"
-#include "BsScriptSpriteTexture.h"
-#include "BsScriptComponent.h"
-#include "BsScriptSceneObject.h"
-#include "BsScriptSerializableObjectInfo.h"
-#include "BsRuntimeScriptObjects.h"
-
-namespace BansheeEngine
-{
-	RTTITypeBase* ScriptSerializableAssemblyInfo::getRTTIStatic()
-	{
-		return ScriptSerializableAssemblyInfoRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableAssemblyInfo::getRTTI() const
-	{
-		return ScriptSerializableAssemblyInfo::getRTTIStatic();
-	}
-
-	ScriptSerializableObjectInfo::ScriptSerializableObjectInfo()
-		:mMonoClass(nullptr), mTypeId(0)
-	{
-
-	}
-
-	RTTITypeBase* ScriptSerializableObjectInfo::getRTTIStatic()
-	{
-		return ScriptSerializableObjectInfoRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableObjectInfo::getRTTI() const
-	{
-		return ScriptSerializableObjectInfo::getRTTIStatic();
-	}
-
-	ScriptSerializableFieldInfo::ScriptSerializableFieldInfo()
-		:mMonoField(nullptr), mFlags((ScriptFieldFlags)0), mFieldId(0)
-	{
-
-	}
-
-	RTTITypeBase* ScriptSerializableFieldInfo::getRTTIStatic()
-	{
-		return ScriptSerializableFieldInfoRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableFieldInfo::getRTTI() const
-	{
-		return ScriptSerializableFieldInfo::getRTTIStatic();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfo::getRTTIStatic()
-	{
-		return ScriptSerializableTypeInfoRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfo::getRTTI() const
-	{
-		return ScriptSerializableTypeInfo::getRTTIStatic();
-	}
-
-	bool ScriptSerializableTypeInfoPrimitive::matches(const ScriptSerializableTypeInfoPtr& typeInfo) const
-	{
-		if(!rtti_is_of_type<ScriptSerializableTypeInfoPrimitive>(typeInfo))
-			return false;
-
-		auto primTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoPrimitive>(typeInfo);
-
-		return primTypeInfo->mType == mType;
-	}
-
-	bool ScriptSerializableTypeInfoPrimitive::isTypeLoaded() const
-	{
-		return true;
-	}
-
-	::MonoClass* ScriptSerializableTypeInfoPrimitive::getMonoClass() const
-	{
-		switch(mType)
-		{
-		case ScriptPrimitiveType::Bool:
-			return mono_get_boolean_class();
-		case ScriptPrimitiveType::Char:
-			return mono_get_char_class();
-		case ScriptPrimitiveType::I8:
-			return mono_get_sbyte_class();
-		case ScriptPrimitiveType::U8:
-			return mono_get_byte_class();
-		case ScriptPrimitiveType::I16:
-			return mono_get_int16_class();
-		case ScriptPrimitiveType::U16:
-			return mono_get_uint16_class();
-		case ScriptPrimitiveType::I32:
-			return mono_get_int32_class();
-		case ScriptPrimitiveType::U32:
-			return mono_get_uint32_class();
-		case ScriptPrimitiveType::I64:
-			return mono_get_int64_class();
-		case ScriptPrimitiveType::U64:
-			return mono_get_uint64_class();
-		case ScriptPrimitiveType::Float:
-			return mono_get_single_class();
-		case ScriptPrimitiveType::Double:
-			return mono_get_double_class();
-		case ScriptPrimitiveType::String:
-			return mono_get_string_class();
-		case ScriptPrimitiveType::TextureRef:
-			return RuntimeScriptObjects::instance().getTextureClass()->_getInternalClass();
-		case ScriptPrimitiveType::SpriteTextureRef:
-			return RuntimeScriptObjects::instance().getSpriteTextureClass()->_getInternalClass();
-		case ScriptPrimitiveType::SceneObjectRef:
-			return RuntimeScriptObjects::instance().getSceneObjectClass()->_getInternalClass();
-		case ScriptPrimitiveType::ComponentRef:
-			return RuntimeScriptObjects::instance().getComponentClass()->_getInternalClass();
-		}
-
-		return nullptr;
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoPrimitive::getRTTIStatic()
-	{
-		return ScriptSerializableTypeInfoPrimitiveRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoPrimitive::getRTTI() const
-	{
-		return ScriptSerializableTypeInfoPrimitive::getRTTIStatic();
-	}
-
-	bool ScriptSerializableTypeInfoObject::matches(const ScriptSerializableTypeInfoPtr& typeInfo) const
-	{
-		if(!rtti_is_of_type<ScriptSerializableTypeInfoObject>(typeInfo))
-			return false;
-
-		auto objTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoObject>(typeInfo);
-
-		return objTypeInfo->mTypeNamespace == mTypeNamespace && objTypeInfo->mTypeName == mTypeName && objTypeInfo->mValueType == mValueType;
-	}
-
-	bool ScriptSerializableTypeInfoObject::isTypeLoaded() const
-	{
-		return RuntimeScriptObjects::instance().hasSerializableObjectInfo(mTypeNamespace, mTypeName);
-	}
-
-	::MonoClass* ScriptSerializableTypeInfoObject::getMonoClass() const
-	{
-		ScriptSerializableObjectInfoPtr objInfo;
-		if(!RuntimeScriptObjects::instance().getSerializableObjectInfo(mTypeNamespace, mTypeName, objInfo))
-			return nullptr;
-
-		return objInfo->mMonoClass->_getInternalClass();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoObject::getRTTIStatic()
-	{
-		return ScriptSerializableTypeInfoObjectRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoObject::getRTTI() const
-	{
-		return ScriptSerializableTypeInfoObject::getRTTIStatic();
-	}
-
-	bool ScriptSerializableTypeInfoArray::matches(const ScriptSerializableTypeInfoPtr& typeInfo) const
-	{
-		if(!rtti_is_of_type<ScriptSerializableTypeInfoArray>(typeInfo))
-			return false;
-
-		auto arrayTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoArray>(typeInfo);
-
-		return arrayTypeInfo->mRank == mRank && arrayTypeInfo->mElementType->matches(mElementType);
-	}
-
-	bool ScriptSerializableTypeInfoArray::isTypeLoaded() const
-	{
-		return mElementType->isTypeLoaded();
-	}
-
-	::MonoClass* ScriptSerializableTypeInfoArray::getMonoClass() const
-	{
-		::MonoClass* elementClass = mElementType->getMonoClass();
-		if(elementClass == nullptr)
-			return nullptr;
-
-		return mono_array_class_get(mElementType->getMonoClass(), mRank);
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoArray::getRTTIStatic()
-	{
-		return ScriptSerializableTypeInfoArrayRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoArray::getRTTI() const
-	{
-		return ScriptSerializableTypeInfoArray::getRTTIStatic();
-	}
-
-	bool ScriptSerializableTypeInfoList::matches(const ScriptSerializableTypeInfoPtr& typeInfo) const
-	{
-		if(!rtti_is_of_type<ScriptSerializableTypeInfoList>(typeInfo))
-			return false;
-
-		auto listTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoList>(typeInfo);
-
-		return listTypeInfo->mElementType->matches(mElementType);
-	}
-
-	bool ScriptSerializableTypeInfoList::isTypeLoaded() const
-	{
-		return mElementType->isTypeLoaded();
-	}
-
-	::MonoClass* ScriptSerializableTypeInfoList::getMonoClass() const
-	{
-		::MonoClass* elementClass = mElementType->getMonoClass();
-		if(elementClass == nullptr)
-			return nullptr;
-
-		MonoClass* genericListClass = RuntimeScriptObjects::instance().getSystemGenericListClass();
-		MonoType* genParams[1] = { mono_class_get_type(elementClass) };
-
-		return mono_class_bind_generic_parameters(genericListClass->_getInternalClass(), 1, genParams, false);
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoList::getRTTIStatic()
-	{
-		return ScriptSerializableTypeInfoListRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoList::getRTTI() const
-	{
-		return ScriptSerializableTypeInfoList::getRTTIStatic();
-	}
-
-	bool ScriptSerializableTypeInfoDictionary::matches(const ScriptSerializableTypeInfoPtr& typeInfo) const
-	{
-		if(!rtti_is_of_type<ScriptSerializableTypeInfoDictionary>(typeInfo))
-			return false;
-
-		auto dictTypeInfo = std::static_pointer_cast<ScriptSerializableTypeInfoDictionary>(typeInfo);
-
-		return dictTypeInfo->mKeyType->matches(mKeyType) && dictTypeInfo->mValueType->matches(mValueType);
-	}
-
-	bool ScriptSerializableTypeInfoDictionary::isTypeLoaded() const
-	{
-		return mKeyType->isTypeLoaded() && mValueType->isTypeLoaded();
-	}
-
-	::MonoClass* ScriptSerializableTypeInfoDictionary::getMonoClass() const
-	{
-		::MonoClass* keyClass = mKeyType->getMonoClass();
-		::MonoClass* valueClass = mValueType->getMonoClass();
-		if(keyClass == nullptr || valueClass == nullptr)
-			return nullptr;
-
-		MonoClass* genericDictionaryClass = RuntimeScriptObjects::instance().getSystemGenericDictionaryClass();
-		MonoType* genParams[2] = { mono_class_get_type(keyClass), mono_class_get_type(valueClass) };
-
-		return mono_class_bind_generic_parameters(genericDictionaryClass->_getInternalClass(), 2, genParams, false);
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoDictionary::getRTTIStatic()
-	{
-		return ScriptSerializableTypeInfoDictionaryRTTI::instance();
-	}
-
-	RTTITypeBase* ScriptSerializableTypeInfoDictionary::getRTTI() const
-	{
-		return ScriptSerializableTypeInfoDictionary::getRTTIStatic();
-	}
-}