More work on Inspector

MBansheeEditor/Inspector/GenericInspector.cs

@@ -14,19 +14,23 @@ namespace BansheeEditor
 
         private void Initialize()
         {
-            SerializableObject serializableObject = new SerializableObject(referencedObject);
-
-            foreach (var field in serializableObject.fields)
+            if (referencedObject != null)
             {
-                if (!field.Inspectable)
-                    continue;
-
-                if (field.HasCustomInspector)
-                    inspectableFields.Add(InspectableObjectBase.CreateCustomInspectable(field.CustomInspectorType, field.Name, field.GetProperty()));
-                else
-                    inspectableFields.Add(InspectableObjectBase.CreateDefaultInspectable(field.Name, field.GetProperty()));
+                SerializableObject serializableObject = new SerializableObject(referencedObject.GetType(), referencedObject);
+
+                foreach (var field in serializableObject.fields)
+                {
+                    if (!field.Inspectable)
+                        continue;
+
+                    if (field.HasCustomInspector)
+                        inspectableFields.Add(InspectableObjectBase.CreateCustomInspectable(field.CustomInspectorType, field.Name, field.GetProperty()));
+                    else
+                        inspectableFields.Add(InspectableObjectBase.CreateDefaultInspectable(field.Name, field.GetProperty()));
+                }
             }
 
+
             // TODO - Add Component foldout
 
             isInitialized = true;

MBansheeEditor/Inspector/InspectableArray.cs

@@ -27,7 +27,7 @@ namespace BansheeEditor
 
         protected void Initialize(GUILayout layout)
         {
-            if (property.Type != SerializableField.FieldType.Array)
+            if (property.Type != SerializableProperty.FieldType.Array)
                 return;
 
             guiLabel = new GUILabel(title);

MBansheeEditor/Inspector/InspectableInt.cs

@@ -21,7 +21,7 @@ namespace BansheeEditor
 
         protected void Initialize(GUILayout layout)
         {
-            if(property.Type == SerializableField.FieldType.Int)
+            if(property.Type == SerializableProperty.FieldType.Int)
             {
                 guiLabel = new GUILabel(title);
                 layout.AddElement(guiLabel); // TODO - Use an IntEditorField

MBansheeEditor/Inspector/InspectableObject.cs

@@ -26,7 +26,7 @@ namespace BansheeEditor
 
         protected void Initialize(GUILayout layout)
         {
-            if (property.Type != SerializableField.FieldType.Object)
+            if (property.Type != SerializableProperty.FieldType.Object)
                 return;
 
             guiLabel = new GUILabel(title);

MBansheeEditor/Inspector/InspectableObjectBase.cs

@@ -74,11 +74,11 @@ namespace BansheeEditor
         {
             switch (property.Type)
             {
-                case SerializableField.FieldType.Int:
+                case SerializableProperty.FieldType.Int:
                     return new InspectableInt(title, property);
-                case SerializableField.FieldType.Object:
+                case SerializableProperty.FieldType.Object:
                     return new InspectableObject(title, property);
-                case SerializableField.FieldType.Array:
+                case SerializableProperty.FieldType.Array:
                     return new InspectableArray(title, property);
                 // TODO - Add all other types
             }

MBansheeEngine/Program.cs

@@ -108,7 +108,7 @@ namespace BansheeEngine
             //Color myColor = dbgStyle.textColor;
             //dbgStyle.textColor = myColor;
 
-            SerializableObject obj = new SerializableObject(new DbgSerzCls());
+            SerializableObject obj = new SerializableObject(typeof(DbgSerzCls), new DbgSerzCls());
 
             Debug.Log(obj.fields.Length);
             for (int i = 0; i < obj.fields.Length; i++)

MBansheeEngine/SerializableArray.cs

@@ -6,19 +6,21 @@ namespace BansheeEngine
     #pragma warning disable 649
     public sealed class SerializableArray : ScriptObject
     {
-        private SerializableField.FieldType elementType;
+        private SerializableProperty.FieldType elementType;
         private Type internalElementType;
         private Array referencedArray;
 
-        public SerializableField.FieldType ElementType
+        public SerializableProperty.FieldType ElementType
         {
             get { return elementType; }
         }
 
-        internal SerializableArray(Array array)
+        // Constructed from native code
+        private SerializableArray(Array array, Type internalElementType)
         {
             referencedArray = array;
-            Internal_CreateInstance(this, referencedArray);
+            this.internalElementType = internalElementType;
+            elementType = SerializableProperty.DetermineFieldType(internalElementType);
         }
 
         public SerializableProperty GetProperty(int elementIdx)
@@ -26,7 +28,10 @@ namespace BansheeEngine
             SerializableProperty.Getter getter = () => referencedArray.GetValue(elementIdx);
             SerializableProperty.Setter setter = (object value) => referencedArray.SetValue(value, elementIdx);
 
-            return new SerializableProperty(ElementType, internalElementType, getter, setter);
+            SerializableProperty property = Internal_CreateProperty(mCachedPtr);
+            property.Construct(ElementType, internalElementType, getter, setter);
+
+            return property;
         }
 
         public int GetLength()
@@ -35,6 +40,6 @@ namespace BansheeEngine
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_CreateInstance(SerializableArray instance, object obj);
+        private static extern SerializableProperty Internal_CreateProperty(IntPtr nativeInstance);
     }
 }

MBansheeEngine/SerializableField.cs

@@ -8,26 +8,8 @@ namespace BansheeEngine
 {
     public class SerializableField : ScriptObject
     {
-        public enum FieldType
-        {
-            Int,
-            Float,
-            Bool,
-            String,
-            Color,
-            Vector2,
-            Vector3,
-            Vector4,
-            GameObjectRef,
-            ResourceRef,
-            Object,
-            Array,
-            List,
-            Dictionary
-        }
-
         private SerializableObject parent;
-        private FieldType type;
+        private SerializableProperty.FieldType type;
         private int flags;
         private Type internalType;
         private string name;
@@ -38,11 +20,11 @@ namespace BansheeEngine
             this.parent = parent;
             this.name = name;
             this.flags = flags;
-            this.type = DetermineFieldType(internalType);
+            this.type = SerializableProperty.DetermineFieldType(internalType);
             this.internalType = internalType;
         }
 
-        public FieldType Type
+        public SerializableProperty.FieldType Type
         {
             get { return type; }
         }
@@ -72,78 +54,20 @@ namespace BansheeEngine
             get { return (flags & 0x01) != 0; } // Flags as defined in native code in BsManagedSerializableObjectInfo.h
         }
 
-        private static FieldType DetermineFieldType(Type internalType)
-        {
-            if (!internalType.IsArray)
-            {
-                if (internalType == typeof (Byte))
-                    return FieldType.Int;
-                else if (internalType == typeof (SByte))
-                    return FieldType.Int;
-                else if (internalType == typeof (Int16))
-                    return FieldType.Int;
-                else if (internalType == typeof (UInt16))
-                    return FieldType.Int;
-                else if (internalType == typeof (Int32))
-                    return FieldType.Int;
-                else if (internalType == typeof (UInt32))
-                    return FieldType.Int;
-                else if (internalType == typeof (Int64))
-                    return FieldType.Int;
-                else if (internalType == typeof (UInt64))
-                    return FieldType.Int;
-                else if (internalType == typeof (bool))
-                    return FieldType.Bool;
-                else if (internalType == typeof (float))
-                    return FieldType.Float;
-                else if (internalType == typeof (double))
-                    return FieldType.Float;
-                else if (internalType == typeof (string))
-                    return FieldType.String;
-                else if (internalType == typeof (Vector2))
-                    return FieldType.Vector2;
-                else if (internalType == typeof (Vector3))
-                    return FieldType.Vector3;
-                else if (internalType == typeof (Vector4))
-                    return FieldType.Vector4;
-                else if (internalType == typeof (Color))
-                    return FieldType.Color;
-                else if (internalType.IsSubclassOf(typeof (GameObject)))
-                    return FieldType.GameObjectRef;
-                else if (internalType.IsSubclassOf(typeof (Resource)))
-                    return FieldType.ResourceRef;
-                else if (internalType.IsGenericType)
-                {
-                    Type genericType = internalType.GetGenericTypeDefinition();
-
-                    if (genericType == typeof (List<>))
-                    {
-                        return FieldType.List;
-                    }
-                    else if (genericType == typeof (Dictionary<,>))
-                    {
-                        return FieldType.Dictionary;
-                    }
-
-                    // Shouldn't happen because native code should only supply us with supported types
-                    throw new Exception("Cannot determine field type. Found an unsupported generic type.");
-                }
-
-                // Otherwise the type must be an object, unless some error occurred
-                return FieldType.Object;
-            }
-
-            return FieldType.Array;
-        }
-
         public SerializableProperty GetProperty()
         {
             SerializableProperty.Getter getter = () => Internal_GetValue(mCachedPtr, parent.referencedObject);
             SerializableProperty.Setter setter = (object value) => Internal_SetValue(mCachedPtr, parent.referencedObject, value);
 
-            return new SerializableProperty(type, internalType, getter, setter);
+            SerializableProperty newProperty = Internal_CreateProperty(mCachedPtr);
+            newProperty.Construct(type, internalType, getter, setter);
+
+            return newProperty;
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern SerializableProperty Internal_CreateProperty(IntPtr nativeInstance);
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern object Internal_GetValue(IntPtr nativeInstance, object instance);
 

MBansheeEngine/SerializableObject.cs

@@ -13,11 +13,17 @@ namespace BansheeEngine
         internal object referencedObject;
         private SerializableField[] _fields;
 
-        public SerializableObject(object obj)
+        public SerializableObject(Type objectType, object instance)
         {
-            Internal_CreateInstance(this, obj);
+            Internal_CreateInstance(this, objectType, instance);
 
-            referencedObject = obj;
+            referencedObject = instance;
+        }
+
+        // Constructed from native code
+        private SerializableObject(object instance)
+        {
+            referencedObject = instance;
         }
 
         public SerializableField[] fields
@@ -26,6 +32,6 @@ namespace BansheeEngine
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_CreateInstance(SerializableObject instance, object obj);
+        private static extern void Internal_CreateInstance(SerializableObject instance, Type objectType, object objInstance);
     }
 }

MBansheeEngine/SerializableProperty.cs

@@ -1,21 +1,44 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace BansheeEngine
 {
-    public sealed class SerializableProperty
+    public sealed class SerializableProperty : ScriptObject
     {
+        public enum FieldType
+        {
+            Int,
+            Float,
+            Bool,
+            String,
+            Color,
+            Vector2,
+            Vector3,
+            Vector4,
+            GameObjectRef,
+            ResourceRef,
+            Object,
+            Array,
+            List,
+            Dictionary
+        }
+
         internal delegate object Getter();
         internal delegate void Setter(object value);
 
-        private SerializableField.FieldType type;
+        private FieldType type;
         private Type internalType;
         private Getter getter;
         private Setter setter;
 
-        internal SerializableProperty(SerializableField.FieldType type, Type internalType, Getter getter, Setter setter)
+        // Constructed from native code
+        private SerializableProperty()
+        { }
+
+        internal void Construct(FieldType type, Type internalType, Getter getter, Setter setter)
         {
             this.type = type;
             this.internalType = internalType;
@@ -23,7 +46,7 @@ namespace BansheeEngine
             this.setter = setter;
         }
 
-        public SerializableField.FieldType Type
+        public FieldType Type
         {
             get { return type; }
         }
@@ -46,18 +69,88 @@ namespace BansheeEngine
 
         public SerializableObject GetObject()
         {
-            if (type != SerializableField.FieldType.Object)
+            if (type != FieldType.Object)
                 throw new Exception("Attempting to retrieve object information from a field that doesn't contain an object.");
 
-            return new SerializableObject(GetValue<object>());
+            return Internal_CreateObject(mCachedPtr, GetValue<object>());
         }
 
         public SerializableArray GetArray()
         {
-            if (type != SerializableField.FieldType.Array)
+            if (type != FieldType.Array)
                 throw new Exception("Attempting to retrieve array information from a field that doesn't contain an array.");
 
-            return new SerializableArray(GetValue<Array>());
+            return Internal_CreateArray(mCachedPtr, GetValue<Array>());
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern SerializableObject Internal_CreateObject(IntPtr nativeInstance, object instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern SerializableArray Internal_CreateArray(IntPtr nativeInstance, Array instance);
+
+        public static FieldType DetermineFieldType(Type internalType)
+        {
+            if (!internalType.IsArray)
+            {
+                if (internalType == typeof (Byte))
+                    return FieldType.Int;
+                else if (internalType == typeof (SByte))
+                    return FieldType.Int;
+                else if (internalType == typeof (Int16))
+                    return FieldType.Int;
+                else if (internalType == typeof (UInt16))
+                    return FieldType.Int;
+                else if (internalType == typeof (Int32))
+                    return FieldType.Int;
+                else if (internalType == typeof (UInt32))
+                    return FieldType.Int;
+                else if (internalType == typeof (Int64))
+                    return FieldType.Int;
+                else if (internalType == typeof (UInt64))
+                    return FieldType.Int;
+                else if (internalType == typeof (bool))
+                    return FieldType.Bool;
+                else if (internalType == typeof (float))
+                    return FieldType.Float;
+                else if (internalType == typeof (double))
+                    return FieldType.Float;
+                else if (internalType == typeof (string))
+                    return FieldType.String;
+                else if (internalType == typeof (Vector2))
+                    return FieldType.Vector2;
+                else if (internalType == typeof (Vector3))
+                    return FieldType.Vector3;
+                else if (internalType == typeof (Vector4))
+                    return FieldType.Vector4;
+                else if (internalType == typeof (Color))
+                    return FieldType.Color;
+                else if (internalType.IsSubclassOf(typeof (GameObject)))
+                    return FieldType.GameObjectRef;
+                else if (internalType.IsSubclassOf(typeof (Resource)))
+                    return FieldType.ResourceRef;
+                else if (internalType.IsGenericType)
+                {
+                    Type genericType = internalType.GetGenericTypeDefinition();
+
+                    if (genericType == typeof (List<>))
+                    {
+                        return FieldType.List;
+                    }
+                    else if (genericType == typeof (Dictionary<,>))
+                    {
+                        return FieldType.Dictionary;
+                    }
+
+                    // Shouldn't happen because native code should only supply us with supported types
+                    throw new Exception("Cannot determine field type. Found an unsupported generic type.");
+                }
+
+                // Otherwise the type must be an object, unless some error occurred
+                return FieldType.Object;
+            }
+
+            return FieldType.Array;
         }
     }
 }

SBansheeEngine/Include/BsScriptSerializableArrayInfo.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "BsScriptObject.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptSerializableArrayInfo : public ScriptObject<ScriptSerializableArrayInfo>
-	{
-	public:
-		static void initMetaData();
-
-	private:
-		static void internal_createInstance(MonoObject* instance, MonoObject* object);
-		static void internal_destroyInstance(ScriptSerializableArrayInfo* nativeInstance);
-
-		static void initRuntimeData();
-
-		ScriptSerializableArrayInfo();
-		~ScriptSerializableArrayInfo() {}
-
-		static MonoField* ElementTypeField;
-	};
-}

SBansheeEngine/Include/BsScriptSerializableField.h

@@ -15,6 +15,7 @@ namespace BansheeEngine
 	private:
 		static void internal_destroyInstance(ScriptSerializableField* nativeInstance);
 
+		static MonoObject* internal_createProperty(ScriptSerializableField* nativeInstance);
 		static MonoObject* internal_getValue(ScriptSerializableField* nativeInstance, MonoObject* instance);
 		static void internal_setValue(ScriptSerializableField* nativeInstance, MonoObject* instance, MonoObject* value);
 

SBansheeEngine/Include/BsScriptSerializableObject.h

@@ -10,15 +10,21 @@ namespace BansheeEngine
 	public:
 		static void initMetaData();
 
+		static ScriptSerializableObject* create(const ManagedSerializableTypeInfoPtr& typeInfo, MonoObject* object);
+
 	private:
-		static void internal_createInstance(MonoObject* instance, MonoObject* object);
+		static void internal_createInstance(MonoObject* instance, MonoReflectionType* type, MonoObject* object);
 		static void internal_destroyInstance(ScriptSerializableObject* nativeInstance);
 
 		static void initRuntimeData();
 
-		ScriptSerializableObject();
+		static ScriptSerializableObject* createInternal(MonoObject* instance, const ManagedSerializableObjectInfoPtr& objInfo);
+
+		ScriptSerializableObject(const ManagedSerializableTypeInfoPtr& typeInfo);
 		~ScriptSerializableObject() {}
 
+		ManagedSerializableTypeInfoPtr mTypeInfo;
+
 		static MonoField* FieldsField;
 	};
 }

SBansheeEngine/Include/BsScriptSerializableProperty.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ScriptSerializableProperty : public ScriptObject<ScriptSerializableProperty>
+	{
+	public:
+		static void initMetaData();
+
+		static ScriptSerializableProperty* create(const ManagedSerializableTypeInfoPtr& typeInfo);
+
+	private:
+		static void internal_destroyInstance(ScriptSerializableProperty* nativeInstance);
+		static MonoObject* internal_createObject(ScriptSerializableProperty* nativeInstance, MonoObject* object);
+		static MonoObject* internal_createArray(ScriptSerializableProperty* nativeInstance, MonoObject* object);
+
+		static void initRuntimeData();
+
+		ScriptSerializableProperty(const ManagedSerializableTypeInfoPtr& typeInfo);
+		~ScriptSerializableProperty() {}
+
+		ManagedSerializableTypeInfoPtr mTypeInfo;
+	};
+}

SBansheeEngine/SBansheeEngine.vcxproj

@@ -267,11 +267,10 @@
     <ClInclude Include="Include\BsScriptSceneObject.h" />
     <ClInclude Include="Include\BsManagedSerializableObjectInfoRTTI.h" />
     <ClInclude Include="Include\BsManagedSerializableObjectRTTI.h" />
-    <ClInclude Include="Include\BsScriptSerializableArrayInfo.h" />
-    <ClInclude Include="Include\BsScriptSerializableDictionaryInfo.h" />
+    <ClInclude Include="Include\BsScriptSerializableArray.h" />
     <ClInclude Include="Include\BsScriptSerializableField.h" />
-    <ClInclude Include="Include\BsScriptSerializableListInfo.h" />
     <ClInclude Include="Include\BsScriptSerializableObject.h" />
+    <ClInclude Include="Include\BsScriptSerializableProperty.h" />
     <ClInclude Include="Include\BsScriptSpriteTexture.h" />
     <ClInclude Include="Include\BsScriptStringTable.h" />
     <ClInclude Include="Include\BsScriptTexture2D.h" />
@@ -310,11 +309,10 @@
     <ClCompile Include="Source\BsManagedSerializableList.cpp" />
     <ClCompile Include="Source\BsManagedSerializableObject.cpp" />
     <ClCompile Include="Source\BsManagedSerializableObjectInfo.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableArrayInfo.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableDictionaryInfo.cpp" />
+    <ClCompile Include="Source\BsScriptSerializableArray.cpp" />
     <ClCompile Include="Source\BsScriptSerializableField.cpp" />
-    <ClCompile Include="Source\BsScriptSerializableListInfo.cpp" />
     <ClCompile Include="Source\BsScriptSerializableObject.cpp" />
+    <ClCompile Include="Source\BsScriptSerializableProperty.cpp" />
     <ClCompile Include="Source\BsScriptSpriteTexture.cpp" />
     <ClCompile Include="Source\BsScriptStringTable.cpp" />
     <ClCompile Include="Source\BsScriptTexture2D.cpp" />

SBansheeEngine/SBansheeEngine.vcxproj.filters

@@ -174,13 +174,10 @@
     <ClInclude Include="Include\BsScriptDebug.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableArrayInfo.h">
+    <ClInclude Include="Include\BsScriptSerializableArray.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableDictionaryInfo.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\BsScriptSerializableListInfo.h">
+    <ClInclude Include="Include\BsScriptSerializableProperty.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
@@ -296,13 +293,10 @@
     <ClCompile Include="Source\BsScriptDebug.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableArrayInfo.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableDictionaryInfo.cpp">
+    <ClCompile Include="Source\BsScriptSerializableArray.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\BsScriptSerializableListInfo.cpp">
+    <ClCompile Include="Source\BsScriptSerializableProperty.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>

SBansheeEngine/Source/BsScriptSerializableArrayInfo.cpp

@@ -1,79 +0,0 @@
-#include "BsScriptSerializableArrayInfo.h"
-#include "BsScriptSerializableField.h"
-#include "BsScriptMeta.h"
-#include "BsMonoField.h"
-#include "BsMonoClass.h"
-#include "BsMonoManager.h"
-#include "BsRuntimeScriptObjects.h"
-#include "BsManagedSerializableArray.h"
-#include "BsManagedSerializableObjectInfo.h"
-
-namespace BansheeEngine
-{
-	MonoField* ScriptSerializableArrayInfo::ElementTypeField = nullptr;
-
-	ScriptSerializableArrayInfo::ScriptSerializableArrayInfo()
-	{
-
-	}
-
-	void ScriptSerializableArrayInfo::initMetaData()
-	{
-		metaData = ScriptMeta(BansheeEngineAssemblyName, "BansheeEngine", "SerializableArrayInfo", &ScriptSerializableArrayInfo::initRuntimeData);
-
-		MonoManager::registerScriptType(&metaData);
-	}
-
-	void ScriptSerializableArrayInfo::initRuntimeData()
-	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptSerializableArrayInfo::internal_createInstance);
-		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptSerializableArrayInfo::internal_destroyInstance);
-
-		ElementTypeField = metaData.scriptClass->getField("elementType");
-	}
-
-	void ScriptSerializableArrayInfo::internal_createInstance(MonoObject* instance, MonoObject* object)
-	{
-		ScriptSerializableArrayInfo* nativeInstance = new (cm_alloc<ScriptSerializableArrayInfo>()) ScriptSerializableArrayInfo();
-		nativeInstance->createInstance(instance);
-
-		metaData.thisPtrField->setValue(instance, &nativeInstance);
-
-
-
-		//MonoManager::instance().findClass(mono_object_get_class(object));
-
-		//RuntimeScriptObjects::instance().determineType()
-
-		//ManagedSerializableArrayPtr serializableArray = ManagedSerializableArray::create(object);
-		//if(serializableObject == nullptr) // Object is not serializable
-		//	return;
-
-		//ManagedSerializableObjectInfoPtr objInfo = serializableObject->getObjectInfo();
-
-		//::MonoClass* serializableFieldClass = ScriptSerializableField::getMetaData()->scriptClass->_getInternalClass();
-
-		//MonoArray* serializableFieldArray = mono_array_new(MonoManager::instance().getDomain(), 
-		//	serializableFieldClass, (UINT32)objInfo->mFields.size());
-
-		//UINT32 i = 0;
-		//for(auto& field : objInfo->mFields)
-		//{
-		//	ScriptSerializableField* serializableField = ScriptSerializableField::create(instance, field.second);
-		//	MonoObject* fieldManagedInstance = serializableField->getManagedInstance();
-
-		//	void* elemAddr = mono_array_addr_with_size(serializableFieldArray, sizeof(MonoObject*), i);
-		//	memcpy(elemAddr, &fieldManagedInstance, sizeof(MonoObject*));
-
-		//	i++;
-		//}
-
-		//FieldsField->setValue(instance, serializableFieldArray);
-	}
-
-	void ScriptSerializableArrayInfo::internal_destroyInstance(ScriptSerializableArrayInfo* nativeInstance)
-	{
-		nativeInstance->~ScriptSerializableArrayInfo();
-		cm_free(nativeInstance);
-	}
-}

SBansheeEngine/Source/BsScriptSerializableField.cpp

@@ -5,6 +5,7 @@
 #include "BsMonoManager.h"
 #include "BsMonoUtil.h"
 #include "BsManagedSerializableObjectInfo.h"
+#include "BsScriptSerializableProperty.h"
 
 namespace BansheeEngine
 {
@@ -24,6 +25,7 @@ namespace BansheeEngine
 	void ScriptSerializableField::initRuntimeData()
 	{
 		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptSerializableField::internal_destroyInstance);
+		metaData.scriptClass->addInternalCall("Internal_CreateProperty", &ScriptSerializableField::internal_createProperty);
 		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptSerializableField::internal_getValue);
 		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptSerializableField::internal_setValue);
 	}
@@ -52,6 +54,13 @@ namespace BansheeEngine
 		cm_free(nativeInstance);
 	}
 
+	MonoObject* ScriptSerializableField::internal_createProperty(ScriptSerializableField* nativeInstance)
+	{
+		ScriptSerializableProperty* newProperty = ScriptSerializableProperty::create(nativeInstance->mFieldInfo->mTypeInfo);
+
+		return newProperty->getManagedInstance();
+	}
+
 	MonoObject* ScriptSerializableField::internal_getValue(ScriptSerializableField* nativeInstance, MonoObject* instance)
 	{
 		return nativeInstance->mFieldInfo->mMonoField->getValueBoxed(instance);

SBansheeEngine/Source/BsScriptSerializableObject.cpp

@@ -1,17 +1,17 @@
 #include "BsScriptSerializableObject.h"
 #include "BsScriptSerializableField.h"
+#include "BsRuntimeScriptObjects.h"
 #include "BsScriptMeta.h"
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "BsManagedSerializableObject.h"
-#include "BsManagedSerializableObjectInfo.h"
 
 namespace BansheeEngine
 {
 	MonoField* ScriptSerializableObject::FieldsField = nullptr;
 
-	ScriptSerializableObject::ScriptSerializableObject()
+	ScriptSerializableObject::ScriptSerializableObject(const ManagedSerializableTypeInfoPtr& typeInfo)
+		:mTypeInfo(typeInfo)
 	{
 
 	}
@@ -31,37 +31,65 @@ namespace BansheeEngine
 		FieldsField = metaData.scriptClass->getField("_fields");
 	}
 
-	void ScriptSerializableObject::internal_createInstance(MonoObject* instance, MonoObject* object)
+	ScriptSerializableObject* ScriptSerializableObject::create(const ManagedSerializableTypeInfoPtr& typeInfo, MonoObject* object)
 	{
-		ScriptSerializableObject* nativeInstance = new (cm_alloc<ScriptSerializableObject>()) ScriptSerializableObject();
-		nativeInstance->createInstance(instance);
+		ManagedSerializableTypeInfoObject* objTypeInfo = static_cast<ManagedSerializableTypeInfoObject*>(typeInfo.get());
 
-		metaData.thisPtrField->setValue(instance, &nativeInstance);
+		ManagedSerializableObjectInfoPtr objInfo;
+		RuntimeScriptObjects::instance().getSerializableObjectInfo(objTypeInfo->mTypeNamespace, objTypeInfo->mTypeName, objInfo);
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+
+		return createInternal(managedInstance, objInfo);
+	}
 
-		ManagedSerializableObjectPtr serializableObject = ManagedSerializableObject::create(object);
-		if(serializableObject == nullptr) // Object is not serializable
-			return;
+	void ScriptSerializableObject::internal_createInstance(MonoObject* instance, MonoReflectionType* type, MonoObject* object)
+	{
+		MonoType* internalType = mono_reflection_type_get_type(type);
+		::MonoClass* monoClass = mono_type_get_class(internalType);
+		String elementNs = mono_class_get_namespace(monoClass);
+		String elementTypeName = mono_class_get_name(monoClass);
 
-		ManagedSerializableObjectInfoPtr objInfo = serializableObject->getObjectInfo();
+		ManagedSerializableObjectInfoPtr objInfo;
+		RuntimeScriptObjects::instance().getSerializableObjectInfo(elementNs, elementTypeName, objInfo);
 
-		::MonoClass* serializableFieldClass = ScriptSerializableField::getMetaData()->scriptClass->_getInternalClass();
+		createInternal(instance, objInfo);
+	}
 
-		MonoArray* serializableFieldArray = mono_array_new(MonoManager::instance().getDomain(), 
-			serializableFieldClass, (UINT32)objInfo->mFields.size());
+	ScriptSerializableObject* ScriptSerializableObject::createInternal(MonoObject* instance, const ManagedSerializableObjectInfoPtr& objInfo)
+	{
+		ManagedSerializableTypeInfoPtr typeInfo;
+		if(objInfo != nullptr)
+			typeInfo = objInfo->mTypeInfo;
 
-		UINT32 i = 0;
-		for(auto& field : objInfo->mFields)
+		ScriptSerializableObject* nativeInstance = new (cm_alloc<ScriptSerializableObject>()) ScriptSerializableObject(typeInfo);
+		nativeInstance->createInstance(instance);
+
+		metaData.thisPtrField->setValue(instance, &nativeInstance);
+
+		if(objInfo != nullptr)
 		{
-			ScriptSerializableField* serializableField = ScriptSerializableField::create(instance, field.second);
-			MonoObject* fieldManagedInstance = serializableField->getManagedInstance();
+			::MonoClass* serializableFieldClass = ScriptSerializableField::getMetaData()->scriptClass->_getInternalClass();
+
+			MonoArray* serializableFieldArray = mono_array_new(MonoManager::instance().getDomain(), 
+				serializableFieldClass, (UINT32)objInfo->mFields.size());
+
+			UINT32 i = 0;
+			for(auto& field : objInfo->mFields)
+			{
+				ScriptSerializableField* serializableField = ScriptSerializableField::create(instance, field.second);
+				MonoObject* fieldManagedInstance = serializableField->getManagedInstance();
+
+				void* elemAddr = mono_array_addr_with_size(serializableFieldArray, sizeof(MonoObject*), i);
+				memcpy(elemAddr, &fieldManagedInstance, sizeof(MonoObject*));
 
-			void* elemAddr = mono_array_addr_with_size(serializableFieldArray, sizeof(MonoObject*), i);
-			memcpy(elemAddr, &fieldManagedInstance, sizeof(MonoObject*));
+				i++;
+			}
 
-			i++;
+			FieldsField->setValue(instance, serializableFieldArray);
 		}
 
-		FieldsField->setValue(instance, serializableFieldArray);
+		return nativeInstance;
 	}
 
 	void ScriptSerializableObject::internal_destroyInstance(ScriptSerializableObject* nativeInstance)

SBansheeEngine/Source/BsScriptSerializableProperty.cpp

@@ -0,0 +1,65 @@
+#include "BsScriptSerializableProperty.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoUtil.h"
+#include "BsManagedSerializableObjectInfo.h"
+#include "BsScriptSerializableObject.h"
+#include "BsScriptSerializableArray.h"
+
+namespace BansheeEngine
+{
+	ScriptSerializableProperty::ScriptSerializableProperty(const ManagedSerializableTypeInfoPtr& typeInfo)
+		:mTypeInfo(typeInfo)
+	{
+
+	}
+
+	void ScriptSerializableProperty::initMetaData()
+	{
+		metaData = ScriptMeta(BansheeEngineAssemblyName, "BansheeEngine", "SerializableProperty", &ScriptSerializableProperty::initRuntimeData);
+
+		MonoManager::registerScriptType(&metaData);
+	}
+
+	void ScriptSerializableProperty::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptSerializableProperty::internal_destroyInstance);
+		metaData.scriptClass->addInternalCall("Internal_CreateObject", &ScriptSerializableProperty::internal_createObject);
+		metaData.scriptClass->addInternalCall("Internal_CreateArray", &ScriptSerializableProperty::internal_createArray);
+	}
+
+	ScriptSerializableProperty* ScriptSerializableProperty::create(const ManagedSerializableTypeInfoPtr& typeInfo)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+
+		ScriptSerializableProperty* nativeInstance = new (cm_alloc<ScriptSerializableProperty>()) ScriptSerializableProperty(typeInfo);
+		nativeInstance->createInstance(managedInstance);
+
+		metaData.thisPtrField->setValue(managedInstance, &nativeInstance);
+
+		return nativeInstance;
+	}
+
+	MonoObject* ScriptSerializableProperty::internal_createObject(ScriptSerializableProperty* nativeInstance, MonoObject* object)
+	{
+		ScriptSerializableObject* newObject = ScriptSerializableObject::create(nativeInstance->mTypeInfo, object);
+
+		return newObject->getManagedInstance();
+	}
+
+	MonoObject* ScriptSerializableProperty::internal_createArray(ScriptSerializableProperty* nativeInstance, MonoObject* object)
+	{
+		ManagedSerializableTypeInfoArrayPtr arrayTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoArray>(nativeInstance->mTypeInfo);
+		ScriptSerializableArray* newObject = ScriptSerializableArray::create(arrayTypeInfo, object);
+
+		return newObject->getManagedInstance();
+	}
+
+	void ScriptSerializableProperty::internal_destroyInstance(ScriptSerializableProperty* nativeInstance)
+	{
+		nativeInstance->~ScriptSerializableProperty();
+		cm_free(nativeInstance);
+	}
+}