Reference ManagedComponents by Type and not by namespace & name string

MBansheeEngine/Component.cs

@@ -10,12 +10,12 @@ namespace BansheeEngine
         { }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern Component Internal_AddComponent(SceneObject parent, string ns, string type);
+        internal static extern Component Internal_AddComponent(SceneObject parent, Type type);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern Component Internal_GetComponent(SceneObject parent, string ns, string type);
+        internal static extern Component Internal_GetComponent(SceneObject parent, Type type);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern Component Internal_RemoveComponent(SceneObject parent, string ns, string type);
+        internal static extern Component Internal_RemoveComponent(SceneObject parent, Type type);
     }
 }

MBansheeEngine/Program.cs

@@ -20,7 +20,7 @@ namespace BansheeEngine
             for (int i = 0; i < so.GetNumChildren(); i++)
             {
                 SceneObject childSO = so.GetChild(i);
-                reportDbgValue(childSO.GetComponent<DbgComponent>().a);
+                reportDbgValue(childSO.GetComponent<DbgComponent>().a, typeof(DbgComponent));
             }
 
             //Color newColor = Color.red;
@@ -34,6 +34,6 @@ namespace BansheeEngine
         private static extern void dbgTestComponentClone(SceneObject so);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void reportDbgValue(int dbgVal);
+        private static extern void reportDbgValue(int dbgVal, Type type);
     }
 }

MBansheeEngine/SceneObject.cs

@@ -25,17 +25,17 @@ namespace BansheeEngine
 
         public T AddComponent<T>() where T : Component
         {
-            return (T)Component.Internal_AddComponent(this, typeof (T).Namespace, typeof (T).Name);
+            return (T)Component.Internal_AddComponent(this, typeof (T));
         }
 
         public T GetComponent<T>() where T : Component
         {
-            return (T)Component.Internal_GetComponent(this, typeof(T).Namespace, typeof(T).Name);
+            return (T)Component.Internal_GetComponent(this, typeof(T));
         }
 
         public void RemoveComponent<T>() where T : Component
         {
-            Component.Internal_RemoveComponent(this, typeof(T).Namespace, typeof(T).Name);
+            Component.Internal_RemoveComponent(this, typeof(T));
         }
 
         public int GetNumChildren()

SBansheeEngine/Include/BsManagedComponent.h

@@ -10,10 +10,12 @@ namespace BansheeEngine
 	{
 	public:
 		MonoObject* getManagedInstance() const { return mManagedInstance; }
+		MonoReflectionType* getRuntimeType() const { return mRuntimeType; }
 		const CM::String& getManagedFullTypeName() const { return mFullTypeName; }
 
 	private:
 		MonoObject* mManagedInstance;
+		MonoReflectionType* mRuntimeType;
 		uint32_t mManagedHandle;
 
 		CM::String mNamespace;
@@ -29,8 +31,8 @@ namespace BansheeEngine
 
 		/** Standard constructor.
         */
-		ManagedComponent(const CM::HSceneObject& parent, const CM::String& ns, const CM::String& typeName);
-		void construct(MonoObject* object);
+		ManagedComponent(const CM::HSceneObject& parent, MonoReflectionType* runtimeType);
+		void construct(MonoObject* object, MonoReflectionType* runtimeType);
 
 		void onDestroyed();
 

SBansheeEngine/Include/BsManagedComponentRTTI.h

@@ -4,6 +4,7 @@
 #include "CmRTTIType.h"
 #include "CmGameObjectRTTI.h"
 #include "BsManagedComponent.h"
+#include "BsMonoManager.h"
 #include "BsScriptSerializableObject.h"
 
 namespace BansheeEngine
@@ -61,7 +62,11 @@ namespace BansheeEngine
 			ManagedComponent* mc = static_cast<ManagedComponent*>(obj);
 			ScriptSerializableObjectPtr serializableObject = boost::any_cast<ScriptSerializableObjectPtr>(mc->mRTTIData);
 
-			mc->construct(serializableObject->getManagedInstance());
+			::MonoClass* monoClass = mono_object_get_class(serializableObject->getManagedInstance());
+			MonoType* monoType = mono_class_get_type(monoClass);
+			MonoReflectionType* runtimeType = mono_type_get_object(MonoManager::instance().getDomain(), monoType);
+
+			mc->construct(serializableObject->getManagedInstance(), runtimeType);
 		}
 
 		virtual const CM::String& getRTTIName()

SBansheeEngine/Include/BsScriptComponent.h

@@ -18,9 +18,9 @@ namespace BansheeEngine
 	private:
 		friend class ScriptGameObjectManager;
 
-		static MonoObject* internal_addComponent(MonoObject* parentSceneObject, MonoString* ns, MonoString* typeName);
-		static MonoObject* internal_getComponent(MonoObject* parentSceneObject, MonoString* ns, MonoString* typeName);
-		static void internal_removeComponent(MonoObject* parentSceneObject, MonoString* ns, MonoString* typeName);
+		static MonoObject* internal_addComponent(MonoObject* parentSceneObject, MonoReflectionType* type);
+		static MonoObject* internal_getComponent(MonoObject* parentSceneObject, MonoReflectionType* type);
+		static void internal_removeComponent(MonoObject* parentSceneObject, MonoReflectionType* type);
 		static void internal_destroyInstance(ScriptComponent* nativeInstance);
 
 		static void initRuntimeData();

SBansheeEngine/Source/BsManagedComponent.cpp

@@ -8,9 +8,15 @@ using namespace CamelotFramework;
 
 namespace BansheeEngine
 {
-	ManagedComponent::ManagedComponent(const CM::HSceneObject& parent, const CM::String& ns, const CM::String& typeName)
-		:mManagedInstance(nullptr), mNamespace(ns), mTypeName(typeName)
+	ManagedComponent::ManagedComponent(const CM::HSceneObject& parent, MonoReflectionType* runtimeType)
+		:mManagedInstance(nullptr), mRuntimeType(runtimeType)
 	{
+		MonoType* monoType = mono_reflection_type_get_type(mRuntimeType);
+		::MonoClass* monoClass = mono_type_get_class(monoType);
+
+		mNamespace = mono_class_get_namespace(monoClass);
+		mTypeName = mono_class_get_name(monoClass);
+
 		MonoClass* managedClass = MonoManager::instance().findClass(mNamespace, mTypeName);
 		if(managedClass == nullptr)
 		{
@@ -18,14 +24,15 @@ namespace BansheeEngine
 			return;
 		}
 
-		construct(managedClass->createInstance());
+		construct(managedClass->createInstance(), runtimeType);
 	}
 
-	void ManagedComponent::construct(MonoObject* object)
+	void ManagedComponent::construct(MonoObject* object, MonoReflectionType* runtimeType)
 	{
 		mFullTypeName = mNamespace + "." + mTypeName;
 
 		mManagedInstance = object;
+		mRuntimeType = runtimeType;
 		mManagedHandle = mono_gchandle_new(mManagedInstance, false);
 	}
 

SBansheeEngine/Source/BsScriptComponent.cpp

@@ -34,15 +34,11 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptComponent::internal_destroyInstance);
 	}
 
-	MonoObject* ScriptComponent::internal_addComponent(MonoObject* parentSceneObject, MonoString* ns, MonoString* typeName)
+	MonoObject* ScriptComponent::internal_addComponent(MonoObject* parentSceneObject, MonoReflectionType* type)
 	{
 		ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(parentSceneObject);
 		HSceneObject so = static_object_cast<SceneObject>(scriptSO->getNativeHandle());
 
-		String strNs = toString(MonoUtil::monoToWString(ns));
-		String strTypeName = toString(MonoUtil::monoToWString(typeName));
-		String fullTypeName = strNs + "." + strTypeName;
-
 		// We only allow single component per type
 		const Vector<HComponent>::type& mComponents = so->getComponents();
 		for(auto& component : mComponents)
@@ -51,29 +47,25 @@ namespace BansheeEngine
 			{
 				GameObjectHandle<ManagedComponent> managedComponent = static_object_cast<ManagedComponent>(component);
 
-				if(managedComponent->getManagedFullTypeName() == fullTypeName)
+				if(managedComponent->getRuntimeType() == type)
 				{
-					LOGWRN("Attempting to add a component \"" + fullTypeName + "\" that already exists on SceneObject \"" + so->getName() + "\"");
+					LOGWRN("Attempting to add a component that already exists on SceneObject \"" + so->getName() + "\"");
 					return managedComponent->getManagedInstance();
 				}
 			}
 		}
 
-		GameObjectHandle<ManagedComponent> mc = so->addComponent<ManagedComponent>(strNs, strTypeName);
+		GameObjectHandle<ManagedComponent> mc = so->addComponent<ManagedComponent>(type);
 		ScriptComponent* nativeInstance = ScriptGameObjectManager::instance().createScriptComponent(mc);
 		
 		return nativeInstance->getManagedInstance();
 	}
 
-	MonoObject* ScriptComponent::internal_getComponent(MonoObject* parentSceneObject, MonoString* ns, MonoString* typeName)
+	MonoObject* ScriptComponent::internal_getComponent(MonoObject* parentSceneObject, MonoReflectionType* type)
 	{
 		ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(parentSceneObject);
 		HSceneObject so = static_object_cast<SceneObject>(scriptSO->getNativeHandle());
 
-		String strNs = toString(MonoUtil::monoToWString(ns));
-		String strTypeName = toString(MonoUtil::monoToWString(typeName));
-		String fullTypeName = strNs + "." + strTypeName;
-
 		const Vector<HComponent>::type& mComponents = so->getComponents();
 		for(auto& component : mComponents)
 		{
@@ -81,7 +73,7 @@ namespace BansheeEngine
 			{
 				GameObjectHandle<ManagedComponent> managedComponent = static_object_cast<ManagedComponent>(component);
 
-				if(managedComponent->getManagedFullTypeName() == fullTypeName)
+				if(managedComponent->getRuntimeType() == type)
 				{
 					return managedComponent->getManagedInstance();
 				}
@@ -91,15 +83,11 @@ namespace BansheeEngine
 		return nullptr;
 	}
 
-	void ScriptComponent::internal_removeComponent(MonoObject* parentSceneObject, MonoString* ns, MonoString* typeName)
+	void ScriptComponent::internal_removeComponent(MonoObject* parentSceneObject, MonoReflectionType* type)
 	{
 		ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(parentSceneObject);
 		HSceneObject so = static_object_cast<SceneObject>(scriptSO->getNativeHandle());
 
-		String strNs = toString(MonoUtil::monoToWString(ns));
-		String strTypeName = toString(MonoUtil::monoToWString(typeName));
-		String fullTypeName = strNs + "." + strTypeName;
-
 		// We only allow single component per type
 		const Vector<HComponent>::type& mComponents = so->getComponents();
 		for(auto& component : mComponents)
@@ -108,7 +96,7 @@ namespace BansheeEngine
 			{
 				GameObjectHandle<ManagedComponent> managedComponent = static_object_cast<ManagedComponent>(component);
 
-				if(managedComponent->getManagedFullTypeName() == fullTypeName)
+				if(managedComponent->getRuntimeType() == type)
 				{
 					managedComponent->destroy();
 					return;
@@ -116,7 +104,7 @@ namespace BansheeEngine
 			}
 		}
 
-		LOGWRN("Attempting to remove a component \"" + fullTypeName + "\" that doesn't exists on SceneObject \"" + so->getName() + "\"");
+		LOGWRN("Attempting to remove a component that doesn't exists on SceneObject \"" + so->getName() + "\"");
 	}
 
 	void ScriptComponent::internal_destroyInstance(ScriptComponent* nativeInstance)

SBansheeEngine/Source/BsScriptEnginePlugin.cpp

@@ -23,8 +23,12 @@ namespace BansheeEngine
 		cloneSO->setParent(SO);
 	}
 
-	void reportDbgValue(int dbgValue)
+	void reportDbgValue(int dbgValue, MonoReflectionType* type)
 	{
+		::MonoClass* monoClass = mono_type_get_class(mono_reflection_type_get_type(type));
+
+		String className = mono_class_get_name(monoClass);
+		
 		int a = dbgValue;
 	}