More fixes to prevent errors at shutdown - Mostly Mono and Script related

BansheeEngine/Include/BsScriptManager.h

@@ -11,6 +11,7 @@ namespace BansheeEngine
 		virtual ~ScriptSystem() { }
 
 		virtual void initialize() = 0;
+		virtual void destroy() = 0;
 	};
 
 	class BS_EXPORT ScriptManager : public Module<ScriptManager>
@@ -20,6 +21,7 @@ namespace BansheeEngine
 		~ScriptManager() { }
 
 		void initialize(const std::shared_ptr<ScriptSystem>& scriptSystem);
+		void destroy();
 
 	private:
 		std::shared_ptr<ScriptSystem> mScriptSystem;

BansheeEngine/Source/BsApplication.cpp

@@ -73,6 +73,7 @@ namespace BansheeEngine
 	{
 		updateCallbackConn.disconnect();
 
+		ScriptManager::instance().destroy();
 		gApplication().unloadPlugin(mSBansheeEnginePlugin);
 		gApplication().unloadPlugin(mMonoPlugin);
 

BansheeEngine/Source/BsScriptManager.cpp

@@ -8,6 +8,12 @@ namespace BansheeEngine
 		mScriptSystem->initialize();
 	}
 
+	void ScriptManager::destroy()
+	{
+		if (mScriptSystem != nullptr)
+			mScriptSystem->destroy();
+	}
+
 	void ScriptManager::onShutDown()
 	{
 		mScriptSystem = nullptr;

BansheeMono/Include/BsMonoScriptManager.h

@@ -13,6 +13,7 @@ namespace BansheeEngine
 		~MonoScriptSystem();
 
 		virtual void initialize();
+		virtual void destroy();
 
 	private:
 		bool mIsInitialized;

BansheeMono/Source/BsMonoManager.cpp

@@ -21,11 +21,11 @@ namespace BansheeEngine
 
 	MonoManager::~MonoManager()
 	{
-		for(auto& entry : mAssemblies)
-		{
-			unloadAssembly(*entry.second); 
-			cm_delete(entry.second);
-		}
+		//for(auto& entry : mAssemblies)
+		//{
+		//	unloadAssembly(*entry.second); 
+		//	cm_delete(entry.second);
+		//}
 
 		mAssemblies.clear();
 

BansheeMono/Source/BsMonoScriptManager.cpp

@@ -20,4 +20,13 @@ namespace BansheeEngine
 		MonoManager::startUp(cm_new<MonoManager>());
 		mIsInitialized = true;
 	}
+
+	void MonoScriptSystem::destroy()
+	{
+		if (mIsInitialized)
+		{
+			MonoManager::shutDown();
+			mIsInitialized = false;
+		}
+	}
 }

CamelotD3D11RenderSystem/Include/CmD3D11GpuProgramRTTI.h

@@ -0,0 +1,170 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmGpuProgramManager.h"
+#include "CmD3D11GpuProgram.h"
+
+namespace BansheeEngine
+{
+	class CM_D3D11_EXPORT D3D11GpuProgramRTTI : public RTTIType<D3D11GpuProgram, GpuProgram, D3D11GpuProgramRTTI>
+	{
+	public:
+		D3D11GpuProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			CM_EXCEPT(InvalidStateException, "Cannot create an instance of an abstract class.");
+		}
+	};
+
+	class CM_D3D11_EXPORT D3D11GpuVertexProgramRTTI : public RTTIType<D3D11GpuVertexProgram, D3D11GpuProgram, D3D11GpuVertexProgramRTTI>
+	{
+	public:
+		D3D11GpuVertexProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuVertexProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuVertexProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("hlsl", GPT_VERTEX_PROGRAM);
+		}
+	};
+
+	class CM_D3D11_EXPORT D3D11GpuFragmentProgramRTTI : public RTTIType<D3D11GpuFragmentProgram, D3D11GpuProgram, D3D11GpuFragmentProgramRTTI>
+	{
+	public:
+		D3D11GpuFragmentProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuFragmentProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuFragmentProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("hlsl", GPT_FRAGMENT_PROGRAM);
+		}
+	};
+
+	class CM_D3D11_EXPORT D3D11GpuGeometryProgramRTTI : public RTTIType<D3D11GpuGeometryProgram, D3D11GpuProgram, D3D11GpuGeometryProgramRTTI>
+	{
+	public:
+		D3D11GpuGeometryProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuGeometryProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuGeometryProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("hlsl", GPT_GEOMETRY_PROGRAM);
+		}
+	};
+
+	class CM_D3D11_EXPORT D3D11GpuHullProgramRTTI : public RTTIType<D3D11GpuHullProgram, D3D11GpuProgram, D3D11GpuHullProgramRTTI>
+	{
+	public:
+		D3D11GpuHullProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuHullProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuHullProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("hlsl", GPT_HULL_PROGRAM);
+		}
+	};
+
+	class CM_D3D11_EXPORT D3D11GpuDomainProgramRTTI : public RTTIType<D3D11GpuDomainProgram, D3D11GpuProgram, D3D11GpuDomainProgramRTTI>
+	{
+	public:
+		D3D11GpuDomainProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuDomainProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuDomainProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("hlsl", GPT_DOMAIN_PROGRAM);
+		}
+	};
+
+	class CM_D3D11_EXPORT D3D11GpuComputeProgramRTTI : public RTTIType<D3D11GpuComputeProgram, D3D11GpuProgram, D3D11GpuComputeProgramRTTI>
+	{
+	public:
+		D3D11GpuComputeProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "D3D11GpuComputeProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_D3D11_GpuComputeProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("hlsl", GPT_COMPUTE_PROGRAM);
+		}
+	};
+}

CamelotGLRenderer/Include/CmGLSLGpuProgramRTTI.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmGpuProgramManager.h"
+#include "CmGLSLGpuProgram.h"
+
+namespace BansheeEngine
+{
+	class CM_RSGL_EXPORT GLSLGpuProgramRTTI : public RTTIType<GLSLGpuProgram, GpuProgram, GLSLGpuProgramRTTI>
+	{
+	public:
+		GLSLGpuProgramRTTI()
+		{ }
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "GLSLGpuProgram";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_GL_GLSLGpuProgram;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return GpuProgramManager::instance().createEmpty("glsl", GPT_VERTEX_PROGRAM);
+		}
+	};
+}

SBansheeEditor/Source/BsScriptEditorWindow.cpp

@@ -65,14 +65,7 @@ namespace BansheeEngine
 
 	void ScriptEditorWindow::_onManagedInstanceDeleted()
 	{
-#if CM_DEBUG_MODE
-		auto iterFind = OpenScriptEditorWindows.find(mName);
-
-		// It is assumed that this method will only be called after "unregisterScriptEditorWindow" is called,
-		// since that is the only place keeping a reference to the managed editor window. So if window was
-		// not removed from OpenScriptEditorWindows array, then something went wrong earlier.
-		assert(iterFind == OpenScriptEditorWindows.end());
-#endif
+		unregisterScriptEditorWindow(mName);
 
 		ScriptObject::_onManagedInstanceDeleted();
 	}

SBansheeEngine/Include/BsScriptComponent.h

@@ -7,7 +7,7 @@
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptComponent : public ScriptGameObject, public ScriptObject<ScriptComponent>
+	class BS_SCR_BE_EXPORT ScriptComponent : public ScriptObject<ScriptComponent, ScriptGameObject>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEngineAssemblyName, "BansheeEngine", "Component")

SBansheeEngine/Include/BsScriptGUIElement.h

@@ -5,31 +5,36 @@
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptGUIElementBase
+	class BS_SCR_BE_EXPORT ScriptGUIElementBase : public ScriptObjectBase
 	{
 	public:
-		ScriptGUIElementBase(GUIElement* element);
+		ScriptGUIElementBase(MonoObject* instance);
 		virtual ~ScriptGUIElementBase() {}
 
 		GUIElement* getGUIElement() const { return (GUIElement*)mElement; }
 
 		virtual void destroy();
 
+	protected:
+		void initialize(GUIElement* element);
+
 	private:
 		bool mIsDestroyed;
 		GUIElement* mElement;
 	};
 
 	template <class Type>
-	class TScriptGUIElement : public ScriptGUIElementBase, public ScriptObject<Type>
+	class TScriptGUIElement : public ScriptObject<Type, ScriptGUIElementBase>
 	{
 	public:
 		virtual ~TScriptGUIElement() {}
 
 	protected:
 		TScriptGUIElement(MonoObject* instance, GUIElement* element)
-			:ScriptGUIElementBase(element), ScriptObject(instance)
-		{ }
+			:ScriptObject(instance)
+		{ 
+			initialize(element);
+		}
 
 		void _onManagedInstanceDeleted()
 		{
@@ -51,6 +56,4 @@ namespace BansheeEngine
 
 		ScriptGUIElement(MonoObject* instance);
 	};
-
-
 }

SBansheeEngine/Include/BsScriptGUIFixedSpace.h

@@ -20,7 +20,6 @@ namespace BansheeEngine
 		ScriptGUIFixedSpace(MonoObject* instance, GUIFixedSpace& fixedSpace, GUILayout* parentLayout);
 
 		void destroy();
-		void _onManagedInstanceDeleted();
 
 		GUIFixedSpace& mFixedSpace;
 		GUILayout* mParentLayout;

SBansheeEngine/Include/BsScriptGUIFlexibleSpace.h

@@ -20,7 +20,6 @@ namespace BansheeEngine
 		ScriptGUIFlexibleSpace(MonoObject* instance, GUIFlexibleSpace& flexibleSpace, GUILayout* parentLayout);
 
 		void destroy();
-		void _onManagedInstanceDeleted();
 
 		GUIFlexibleSpace& mFlexibleSpace;
 		GUILayout* mParentLayout;

SBansheeEngine/Include/BsScriptGUILayout.h

@@ -26,7 +26,6 @@ namespace BansheeEngine
 		ScriptGUILayout(MonoObject* instance, GUILayout* layout, GUILayout* parentLayout);
 
 		void destroy();
-		void _onManagedInstanceDeleted();
 
 		GUILayout* mLayout;
 		GUILayout* mParentLayout;

SBansheeEngine/Include/BsScriptGameObject.h

@@ -1,12 +1,18 @@
 #pragma once
 
 #include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptGameObject
+	class BS_SCR_BE_EXPORT ScriptGameObject : public ScriptObjectBase
 	{
 	public:
+		ScriptGameObject(MonoObject* instance)
+			:ScriptObjectBase(instance)
+		{ }
+		virtual ~ScriptGameObject() { }
+
 		virtual HGameObject getNativeHandle() const = 0;
 		virtual void setNativeHandle(const HGameObject& gameObject) = 0;
 	};

SBansheeEngine/Include/BsScriptObject.h

@@ -9,13 +9,13 @@
 
 namespace BansheeEngine
 {
-	template <class Type>
+	template <class Type, class Base>
 	struct InitScriptObjectOnStart
 	{
 	public:
 		InitScriptObjectOnStart()
 		{
-			ScriptObject<Type>::_initMetaData();
+			ScriptObject<Type, Base>::_initMetaData();
 		}
 
 		void makeSureIAmInstantiated() { }
@@ -40,19 +40,19 @@ namespace BansheeEngine
 	/**
 	 * @brief	 Base class for objects that can be extended using Mono scripting
 	 */
-	template <class Type>
-	class ScriptObject : public ScriptObjectBase
+	template <class Type, class Base = ScriptObjectBase>
+	class ScriptObject : public Base
 	{
 	public:
 		ScriptObject(MonoObject* instance)
-			:ScriptObjectBase(instance)
+			:Base(instance)
 		{	
 			// Compiler will only generate code for stuff that is directly used, including static data members,
 			// so we fool it here like we're using the class directly. Otherwise compiler won't generate the code for the member
 			// and our type won't get initialized on start (Actual behavior is a bit more random)
 			initOnStart.makeSureIAmInstantiated();
 
-			Type* param = (Type*)(ScriptObjectBase*)this; // Needed due to multiple inheritance. Safe since Type must point to an class derived from this one.
+			Type* param = (Type*)(Base*)this; // Needed due to multiple inheritance. Safe since Type must point to an class derived from this one.
 
 			if(metaData.thisPtrField != nullptr)
 				metaData.thisPtrField->setValue(instance, &param);
@@ -83,8 +83,8 @@ namespace BansheeEngine
 	protected:
 		static ScriptMeta metaData;
 
-		template <class Type2>
-		static void throwIfInstancesDontMatch(ScriptObject<Type2>* lhs, void* rhs)
+		template <class Type2, class Base2>
+		static void throwIfInstancesDontMatch(ScriptObject<Type2, Base2>* lhs, void* rhs)
 		{
 #if CM_DEBUG_MODE
 			if((lhs == nullptr && rhs != nullptr) || (rhs == nullptr && lhs != nullptr) || lhs->getNativeRaw() != rhs)
@@ -96,14 +96,14 @@ namespace BansheeEngine
 		}
 
 	private:
-		static InitScriptObjectOnStart<Type> initOnStart;
+		static InitScriptObjectOnStart<Type, Base> initOnStart;
 	};
 
-	template <typename Type>
-	InitScriptObjectOnStart<Type> ScriptObject<Type>::initOnStart;
+	template <typename Type, typename Base>
+	InitScriptObjectOnStart<Type, Base> ScriptObject<Type, Base>::initOnStart;
 
-	template <typename Type>
-	ScriptMeta ScriptObject<Type>::metaData;
+	template <typename Type, typename Base>
+	ScriptMeta ScriptObject<Type, Base>::metaData;
 
 #define SCRIPT_OBJ(assembly, namespace, name)		\
 	static String getAssemblyName() { return assembly; }	\

SBansheeEngine/Include/BsScriptResource.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptResource
+	class BS_SCR_BE_EXPORT ScriptResource : public ScriptObjectBase
 	{
 	public:
 		virtual HResource getNativeHandle() const = 0;
@@ -13,7 +14,9 @@ namespace BansheeEngine
 	protected:
 		friend class ScriptResourceManager;
 
-		ScriptResource() {}
+		ScriptResource(MonoObject* instance)
+			:ScriptObjectBase(instance)
+		{ }
 		virtual ~ScriptResource() {}
 	};
 }

SBansheeEngine/Include/BsScriptSceneObject.h

@@ -7,7 +7,7 @@
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptSceneObject : public ScriptGameObject, public ScriptObject<ScriptSceneObject>
+	class BS_SCR_BE_EXPORT ScriptSceneObject : public ScriptObject<ScriptSceneObject, ScriptGameObject>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEngineAssemblyName, "BansheeEngine", "SceneObject")

SBansheeEngine/Include/BsScriptSpriteTexture.h

@@ -6,7 +6,7 @@
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptSpriteTexture : public ScriptResource, public ScriptObject<ScriptSpriteTexture>
+	class BS_SCR_BE_EXPORT ScriptSpriteTexture : public ScriptObject<ScriptSpriteTexture, ScriptResource>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEngineAssemblyName, "BansheeEngine", "SpriteTexture")

SBansheeEngine/Include/BsScriptTexture2D.h

@@ -7,7 +7,7 @@
 
 namespace BansheeEngine
 {
-	class BS_SCR_BE_EXPORT ScriptTexture2D : public ScriptResource, public ScriptObject<ScriptTexture2D>
+	class BS_SCR_BE_EXPORT ScriptTexture2D : public ScriptObject<ScriptTexture2D, ScriptResource>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEngineAssemblyName, "BansheeEngine", "Texture2D")

SBansheeEngine/Source/BsScriptComponent.cpp

@@ -128,6 +128,7 @@ namespace BansheeEngine
 
 	void ScriptComponent::_onManagedInstanceDeleted()
 	{
+		mManagedInstance = nullptr;
 		ScriptGameObjectManager::instance().destroyScriptGameObject(this);
 	}
 

SBansheeEngine/Source/BsScriptGUIElement.cpp

@@ -11,8 +11,8 @@
 
 namespace BansheeEngine
 {
-	ScriptGUIElementBase::ScriptGUIElementBase(GUIElement* element)
-		:mIsDestroyed(false), mElement(element)
+	ScriptGUIElementBase::ScriptGUIElementBase(MonoObject* instance)
+		:ScriptObjectBase(instance), mIsDestroyed(false), mElement(nullptr)
 	{ }
 
 	ScriptGUIElement::ScriptGUIElement(MonoObject* instance)
@@ -21,6 +21,11 @@ namespace BansheeEngine
 
 	}
 
+	void ScriptGUIElementBase::initialize(GUIElement* element)
+	{
+		mElement = element;
+	}
+
 	void ScriptGUIElementBase::destroy()
 	{
 		if(!mIsDestroyed)

SBansheeEngine/Source/BsScriptGUIFixedSpace.cpp

@@ -37,13 +37,6 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScriptGUIFixedSpace::_onManagedInstanceDeleted()
-	{
-		destroy();
-
-		ScriptObject::_onManagedInstanceDeleted();
-	}
-
 	void ScriptGUIFixedSpace::internal_createInstance(MonoObject* instance, MonoObject* parentLayout, UINT32 size)
 	{
 		ScriptGUILayout* scriptLayout = ScriptGUILayout::toNative(parentLayout);

SBansheeEngine/Source/BsScriptGUIFlexibleSpace.cpp

@@ -37,13 +37,6 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScriptGUIFlexibleSpace::_onManagedInstanceDeleted()
-	{
-		destroy();
-
-		ScriptObject::_onManagedInstanceDeleted();
-	}
-
 	void ScriptGUIFlexibleSpace::internal_createInstance(MonoObject* instance, MonoObject* parentLayout)
 	{
 		ScriptGUILayout* scriptLayout = ScriptGUILayout::toNative(parentLayout);

SBansheeEngine/Source/BsScriptGUILayout.cpp

@@ -43,13 +43,6 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScriptGUILayout::_onManagedInstanceDeleted()
-	{
-		destroy();
-
-		ScriptObject::_onManagedInstanceDeleted();
-	}
-
 	void ScriptGUILayout::internal_createInstanceXFromArea(MonoObject* instance, MonoObject* parentArea)
 	{
 		ScriptGUIArea* scriptArea = ScriptGUIArea::toNative(parentArea);

SBansheeEngine/Source/BsScriptObject.cpp

@@ -16,8 +16,17 @@ namespace BansheeEngine
 			CM_EXCEPT(InvalidStateException, "Script object is being destroyed without its instance previously being released.");
 	}
 
+	static Vector<UINT64> dbgList;
 	void ScriptObjectBase::_onManagedInstanceDeleted()
 	{
+		auto iterFind = std::find(dbgList.begin(), dbgList.end(), (UINT64)this);
+		if (iterFind != dbgList.end())
+		{
+			assert(false);
+		}
+
+		dbgList.push_back((UINT64)this);
+
 		mManagedInstance = nullptr;
 		cm_delete(this);
 	}

SBansheeEngine/Source/BsScriptSceneObject.cpp

@@ -74,6 +74,7 @@ namespace BansheeEngine
 
 	void ScriptSceneObject::_onManagedInstanceDeleted()
 	{
+		mManagedInstance = nullptr;
 		ScriptGameObjectManager::instance().destroyScriptGameObject(this);
 	}
 

SBansheeEngine/Source/BsScriptSpriteTexture.cpp

@@ -26,6 +26,7 @@ namespace BansheeEngine
 
 	void ScriptSpriteTexture::_onManagedInstanceDeleted()
 	{
+		mManagedInstance = nullptr;
 		ScriptResourceManager::instance().destroyScriptResource(this);
 	}
 

SBansheeEngine/Source/BsScriptTexture2D.cpp

@@ -47,6 +47,7 @@ namespace BansheeEngine
 
 	void ScriptTexture2D::_onManagedInstanceDeleted()
 	{
+		mManagedInstance = nullptr;
 		ScriptResourceManager::instance().destroyScriptResource(this);
 	}