Mono scripting start and first Script class

BansheeEngine.sln

@@ -329,7 +329,6 @@ Global
 		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|Win32.ActiveCfg = Debug|Win32
 		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|Win32.Build.0 = Debug|Win32
 		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|x64.ActiveCfg = Debug|x64
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|x64.Build.0 = Debug|x64
 		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|Any CPU.ActiveCfg = DebugRelease|Win32
 		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|Mixed Platforms.ActiveCfg = DebugRelease|Win32
 		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|Mixed Platforms.Build.0 = DebugRelease|Win32
@@ -434,6 +433,7 @@ Global
 		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.Debug|x64.Build.0 = Debug|Any CPU
 		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.DebugRelease|Any CPU.ActiveCfg = Release|Any CPU
 		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.DebugRelease|Any CPU.Build.0 = Release|Any CPU
 		{876EB338-489E-4727-84DA-8CBBF0DA5B5E}.DebugRelease|Mixed Platforms.ActiveCfg = Release|Any CPU
@@ -452,6 +452,7 @@ Global
 		{ABC62E37-342E-4345-A374-E37CA06C036E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{ABC62E37-342E-4345-A374-E37CA06C036E}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{ABC62E37-342E-4345-A374-E37CA06C036E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{ABC62E37-342E-4345-A374-E37CA06C036E}.Debug|x64.Build.0 = Debug|Any CPU
 		{ABC62E37-342E-4345-A374-E37CA06C036E}.DebugRelease|Any CPU.ActiveCfg = Release|Any CPU
 		{ABC62E37-342E-4345-A374-E37CA06C036E}.DebugRelease|Any CPU.Build.0 = Release|Any CPU
 		{ABC62E37-342E-4345-A374-E37CA06C036E}.DebugRelease|Mixed Platforms.ActiveCfg = Release|Any CPU

BansheeEngine/BansheeEngine.vcxproj

@@ -127,7 +127,7 @@
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>..\lib\x86\$(Configuration);..\Dependencies\lib\x86\Debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;libmonosgen-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;mono-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImportLibrary>..\lib\x86\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
   </ItemDefinitionGroup>
@@ -141,7 +141,7 @@
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>..\lib\$(Platform)\$(Configuration);..\Dependencies\lib\x64\Debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;mono-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImportLibrary>..\lib\$(Platform)\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
   </ItemDefinitionGroup>
@@ -161,7 +161,7 @@
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalLibraryDirectories>..\lib\x86\$(Configuration);..\Dependencies\lib\x86\Release</AdditionalLibraryDirectories>
-      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;mono-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImportLibrary>..\lib\x86\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
   </ItemDefinitionGroup>
@@ -181,7 +181,7 @@
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalLibraryDirectories>..\lib\x86\$(Configuration);..\Dependencies\lib\x86\DebugRelease</AdditionalLibraryDirectories>
-      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;mono-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImportLibrary>..\lib\x86\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
   </ItemDefinitionGroup>
@@ -201,7 +201,7 @@
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalLibraryDirectories>..\lib\$(Platform)\$(Configuration);..\Dependencies\lib\x64\Release</AdditionalLibraryDirectories>
-      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;mono-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImportLibrary>..\lib\$(Platform)\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
   </ItemDefinitionGroup>
@@ -221,7 +221,7 @@
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalLibraryDirectories>..\lib\$(Platform)\$(Configuration);..\Dependencies\lib\x64\DebugRelease</AdditionalLibraryDirectories>
-      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotCore.lib;CamelotUtility.lib;mono-2.0.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImportLibrary>..\lib\$(Platform)\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
   </ItemDefinitionGroup>
@@ -231,6 +231,7 @@
     <ClInclude Include="Include\BsDrawHelperTemplate.h" />
     <ClInclude Include="Include\BsDragAndDropManager.h" />
     <ClInclude Include="Include\BsDrawHelper2D.h" />
+    <ClInclude Include="Include\BsEngineAssembly.h" />
     <ClInclude Include="Include\BsEngineGUI.h" />
     <ClInclude Include="Include\BsGUIArea.h" />
     <ClInclude Include="Include\BsGUIButton.h" />
@@ -279,6 +280,13 @@
     <ClInclude Include="Include\BsProfilerOverlay.h" />
     <ClInclude Include="Include\BsSceneManager.h" />
     <ClInclude Include="Include\BsGUIScrollArea.h" />
+    <ClInclude Include="Include\BsScriptAssembly.h" />
+    <ClInclude Include="Include\BsScriptClass.h" />
+    <ClInclude Include="Include\BsScriptField.h" />
+    <ClInclude Include="Include\BsScriptManager.h" />
+    <ClInclude Include="Include\BsScriptMethod.h" />
+    <ClInclude Include="Include\BsScriptObject.h" />
+    <ClInclude Include="Include\BsScriptTexture2D.h" />
     <ClInclude Include="Include\BsSprite.h" />
     <ClInclude Include="Include\BsSpriteTexture.h" />
     <ClInclude Include="Include\BsTextSprite.h" />
@@ -293,8 +301,10 @@
     <ClInclude Include="Include\BsD3D9BuiltinMaterialFactory.h" />
     <ClInclude Include="Include\BsGLBuiltinMaterialFactory.h" />
     <ClInclude Include="Include\BsUpdateCallback.h" />
+    <ClCompile Include="Source\BsEngineAssembly.cpp" />
     <ClCompile Include="Source\BsGUIButtonBase.cpp" />
     <ClCompile Include="Source\BsGUIContextMenu.cpp" />
+    <ClInclude Include="Include\BsScriptMeta.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsApplication.cpp" />
@@ -339,6 +349,13 @@
     <ClCompile Include="Source\BsProfilerOverlay.cpp" />
     <ClCompile Include="Source\BsSceneManager.cpp" />
     <ClCompile Include="Source\BsGUIScrollArea.cpp" />
+    <ClCompile Include="Source\BsScriptAssembly.cpp" />
+    <ClCompile Include="Source\BsScriptClass.cpp" />
+    <ClCompile Include="Source\BsScriptField.cpp" />
+    <ClCompile Include="Source\BsScriptManager.cpp" />
+    <ClCompile Include="Source\BsScriptMethod.cpp" />
+    <ClCompile Include="Source\BsScriptMeta.cpp" />
+    <ClCompile Include="Source\BsScriptTexture2D.cpp" />
     <ClCompile Include="Source\BsSprite.cpp" />
     <ClCompile Include="Source\BsSpriteTexture.cpp" />
     <ClCompile Include="Source\BsTextSprite.cpp" />

BansheeEngine/BansheeEngine.vcxproj.filters

@@ -34,6 +34,12 @@
     <Filter Include="Header Files\RTTI">
       <UniqueIdentifier>{8d0002f5-5505-4292-9043-a8fbb489362e}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\Script">
+      <UniqueIdentifier>{316651aa-66a0-49dc-8f54-dcc0e037d6b7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Script">
+      <UniqueIdentifier>{74630e1e-ef0d-4dbc-9e23-0ae6ea24fc02}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Include\BsPrerequisites.h">
@@ -237,6 +243,33 @@
     <ClInclude Include="Include\BsDebugDrawMaterialInfo.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptAssembly.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptClass.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptManager.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptMethod.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptObject.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptMeta.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsEngineAssembly.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptField.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptTexture2D.h">
+      <Filter>Header Files\Script</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsGUIElement.cpp">
@@ -416,5 +449,29 @@
     <ClCompile Include="Source\BsGUIRenderTexture.cpp">
       <Filter>Source Files\GUI</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptAssembly.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptClass.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptManager.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptMethod.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptMeta.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptTexture2D.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptField.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsEngineAssembly.cpp">
+      <Filter>Source Files\Script</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

BansheeEngine/Include/BsEngineAssembly.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsScriptAssembly.h"
+#include "CmModule.h"
+
+namespace BansheeEngine
+{
+	class BS_EXPORT EngineAssembly : public CM::Module<EngineAssembly>
+	{
+	public:
+		EngineAssembly();
+		~EngineAssembly();
+
+		ScriptAssembly& getAssembly() const { return *mAssembly; }
+
+	private:
+		static const CM::String ENGINE_ASSEMBLY_PATH;
+		static const CM::String ENGINE_ASSEMBLY_NAME;
+
+		ScriptAssembly* mAssembly;
+	};
+
+	ScriptAssembly& gEngineAssembly();
+}

BansheeEngine/Include/BsPrerequisites.h

@@ -63,6 +63,13 @@ namespace BansheeEngine
 	class GUIContent;
 	class GUIContextMenu;
 
+	// Script
+	class ScriptManager;
+	class ScriptAssembly;
+	class ScriptClass;
+	class ScriptMethod;
+	class ScriptField;
+
 	// 2D
 	class TextSprite;
 	class ImageSprite;

BansheeEngine/Include/BsScriptAssembly.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include <mono/jit/jit.h>
+#include <mono/metadata/assembly.h>
+
+namespace BansheeEngine
+{
+	class BS_EXPORT ScriptAssembly
+	{
+		struct ClassId
+		{
+			struct Hash
+			{
+				inline size_t operator()(const ClassId& v) const;
+			};
+
+			struct Equals
+			{
+				inline bool operator()(const ClassId &a, const ClassId &b) const;
+			};
+
+			ClassId(const CM::String& namespaceName, CM::String name);
+
+			CM::String namespaceName;
+			CM::String name;
+		};
+
+	public:
+		~ScriptAssembly();
+
+		ScriptClass& getClass(const CM::String& namespaceName, const CM::String& name);
+
+	private:
+		friend class ScriptManager;
+
+		ScriptAssembly(MonoAssembly* assembly);
+
+		void load(MonoAssembly* assembly);
+		void unload();
+
+		MonoImage* mMonoImage;
+		MonoAssembly* mMonoAssembly;
+		bool mIsLoaded;
+		CM::UnorderedMap<ClassId, ScriptClass*, ClassId::Hash, ClassId::Equals>::type mClasses;
+	};
+}

BansheeEngine/Include/BsScriptClass.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	class BS_EXPORT ScriptClass
+	{
+		struct MethodId
+		{
+			struct Hash
+			{
+				inline size_t operator()(const MethodId& v) const;
+			};
+			
+			struct Equals
+			{
+				inline bool operator()(const MethodId &a, const MethodId &b) const;
+			};
+
+			MethodId(const CM::String& name, CM::UINT32 numParams);
+
+			CM::String name;
+			CM::UINT32 numParams;
+		};
+
+	public:
+		~ScriptClass();
+
+		ScriptMethod& getMethod(const CM::String& name, CM::UINT32 numParams = 0);
+		ScriptField& getField(const CM::String name);
+		
+		MonoObject* invokeMethod(const CM::String& name, MonoObject* instance = nullptr, void** params = nullptr, CM::UINT32 numParams = 0);
+		void addInternalCall(const CM::String& name, const void* method);
+	private:
+		friend class ScriptAssembly;
+
+		ScriptClass(const CM::String& fullName, MonoClass* monoClass);
+
+		MonoClass* mClass;
+		CM::String mFullName;
+
+		CM::UnorderedMap<MethodId, ScriptMethod*, MethodId::Hash, MethodId::Equals>::type mMethods; 
+		CM::UnorderedMap<CM::String, ScriptField*>::type mFields; 
+	};
+}

BansheeEngine/Include/BsScriptField.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include <mono/jit/jit.h>
+#include <mono/metadata/class.h>
+
+namespace BansheeEngine
+{
+	class BS_EXPORT ScriptField
+	{
+	public:
+		void* getValue(MonoObject* instance);
+		void setValue(MonoObject* instance, void* value);
+
+	private:
+		friend class ScriptClass;
+
+		ScriptField(MonoClassField* field);
+
+		MonoClassField* mField;
+		void* mThunk;
+	};
+}

BansheeEngine/Include/BsScriptManager.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsScriptMeta.h"
+#include "CmModule.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	/**
+	 * @brief	Loads Mono script assemblies and manages script objects.
+	 */
+	class BS_EXPORT ScriptManager : public CM::Module<ScriptManager>
+	{
+	public:
+		ScriptManager();
+		~ScriptManager();
+
+		ScriptAssembly& loadAssembly(const CM::String& path, const CM::String& name);
+		void unloadAssembly(ScriptAssembly& assembly);
+
+		MonoDomain* getDomain() const { return mDomain; }
+
+		static void registerScriptType(ScriptMeta* metaData);
+	private:
+		static const CM::String DOMAIN_NAME;
+		static const CM::String MONO_LIB_DIR;
+		static const CM::String MONO_ETC_DIR;
+
+		static CM::UnorderedMap<CM::String, CM::Vector<ScriptMeta*>::type>::type mTypesToInitialize;
+
+		MonoDomain* mDomain;
+		CM::UnorderedMap<CM::String, ScriptAssembly*>::type mAssemblies;
+	};
+}

BansheeEngine/Include/BsScriptMeta.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+
+namespace BansheeEngine
+{
+	struct BS_EXPORT ScriptMeta
+	{
+		ScriptMeta();
+		ScriptMeta(const CM::String& assembly, const CM::String& ns, const CM::String& name, std::function<void()> initCallback);
+
+		CM::String ns;
+		CM::String name;
+		CM::String assembly;
+		std::function<void()> initCallback;
+		ScriptClass* scriptClass;							
+		ScriptField* thisPtrField;	
+	};
+}

CamelotCore/Include/CmScriptMethod.h → BansheeEngine/Include/BsScriptMethod.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#include "CmPrerequisites.h"
+#include "BsPrerequisites.h"
 #include <mono/jit/jit.h>
 
-namespace CamelotFramework
+namespace BansheeEngine
 {
-	class CM_EXPORT ScriptMethod
+	class BS_EXPORT ScriptMethod
 	{
 	public:
-		MonoObject* invoke(ScriptObject* instance, void** params);
+		MonoObject* invoke(MonoObject* instance, void** params);
 
 		/**
 		 * @brief	Gets a thunk for this method. A thunk is a C++ like function

BansheeEngine/Include/BsScriptObject.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsScriptMeta.h"
+#include "CmException.h"
+#include <mono/jit/jit.h>
+
+namespace BansheeEngine
+{
+	template <class Type>
+	struct InitScriptObjectOnStart
+	{
+	public:
+		InitScriptObjectOnStart()
+		{
+			Type::initMetaData();
+		}
+
+		void makeSureIAmInstantiated() { }
+	};
+
+	/**
+	 * @brief	 Base class for objects that can be extended using Mono scripting
+	 */
+	template <class Type>
+	class BS_EXPORT ScriptObject
+	{
+	public:
+		ScriptObject()
+			:mInstanceCreated(false)
+		{	
+			// 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();
+		}
+
+		virtual ~ScriptObject() 
+		{
+			if(mInstanceCreated)
+				CM_EXCEPT(InvalidStateException, "Script object is being destroyed without its instance previously being released.");
+		}
+
+	protected:
+		static ScriptMeta metaData;
+
+		bool mInstanceCreated;
+
+		void createInstance()
+		{
+			if(mInstanceCreated)
+				CM_EXCEPT(InvalidStateException, "Trying to instantiate an already instantiated script object.");
+
+			mInstanceCreated = true;
+		}
+
+		void destroyInstance()
+		{
+			if(!mInstanceCreated)
+				return;
+
+			mInstanceCreated = false;
+		}
+
+	private:
+		static InitScriptObjectOnStart<Type> initOnStart;
+	};
+
+	template <typename Type>
+	InitScriptObjectOnStart<Type> ScriptObject<Type>::initOnStart;
+
+	template <typename Type>
+	ScriptMeta ScriptObject<Type>::metaData;
+}

BansheeEngine/Include/BsScriptTexture2D.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsScriptObject.h"
+#include "CmTexture.h"
+
+namespace BansheeEngine
+{
+	class BS_EXPORT ScriptTexture : public ScriptObject<ScriptTexture>
+	{
+	public:
+		static void initMetaData();
+
+	private:
+		static void internal_createInstance(MonoObject* instance, CM::UINT32 format, CM::UINT32 width, CM::UINT32 height, bool hasMipmaps, bool gammaCorrection);
+		static void internal_destroyInstance(ScriptTexture* nativeInstance);
+
+		static void initRuntimeData();
+
+		ScriptTexture(const CM::HTexture& texture);
+
+		CM::HTexture mTexture;
+	};
+}

BansheeEngine/Source/BsEngineAssembly.cpp

@@ -0,0 +1,25 @@
+#include "BsEngineAssembly.h"
+#include "BsScriptManager.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	const CM::String EngineAssembly::ENGINE_ASSEMBLY_PATH = "..\\..\\Assemblies\\MBansheeEngine.dll";
+	const CM::String EngineAssembly::ENGINE_ASSEMBLY_NAME = "MBansheeEngine";
+
+	EngineAssembly::EngineAssembly()
+	{
+		mAssembly = &ScriptManager::instance().loadAssembly(ENGINE_ASSEMBLY_PATH, ENGINE_ASSEMBLY_NAME);
+	}
+
+	EngineAssembly::~EngineAssembly()
+	{
+		ScriptManager::instance().unloadAssembly(*mAssembly);
+	}
+
+	ScriptAssembly& gEngineAssembly()
+	{
+		return EngineAssembly::instance().getAssembly();
+	}
+}

CamelotCore/Source/CmScriptAssembly.cpp → BansheeEngine/Source/BsScriptAssembly.cpp

@@ -1,9 +1,11 @@
-#include "CmScriptAssembly.h"
-#include "CmScriptClass.h"
+#include "BsScriptAssembly.h"
+#include "BsScriptClass.h"
 #include "CmUtil.h"
 #include "CmException.h"
 
-namespace CamelotFramework
+using namespace CamelotFramework;
+
+namespace BansheeEngine
 {
 	inline size_t ScriptAssembly::ClassId::Hash::operator()(const ScriptAssembly::ClassId& v) const
 	{
@@ -25,25 +27,47 @@ namespace CamelotFramework
 	}
 
 	ScriptAssembly::ScriptAssembly(MonoAssembly* assembly)
-		:mMonoAssembly(assembly)
 	{
+		load(assembly);
+	}
+
+	ScriptAssembly::~ScriptAssembly()
+	{
+		for(auto& entry : mClasses)
+			cm_delete(entry.second);
+
+		mClasses.clear();
+	}
+
+	void ScriptAssembly::load(MonoAssembly* assembly)
+	{
+		mMonoAssembly = assembly;
 		mMonoImage = mono_assembly_get_image(mMonoAssembly);
 		if(mMonoImage == nullptr)
 		{
 			CM_EXCEPT(InvalidParametersException, "Cannot get script assembly image.");
 		}
+
+		mIsLoaded = true;
 	}
 
-	ScriptAssembly::~ScriptAssembly()
+	void ScriptAssembly::unload()
 	{
-		for(auto& entry : mClasses)
-			cm_delete(entry.second);
+		if(mMonoImage)
+		{
+			mono_image_close(mMonoImage);
+			mMonoImage = nullptr;
+		}
 
-		mClasses.clear();
+		mIsLoaded = false;
+		mMonoAssembly = nullptr;
 	}
 
 	ScriptClass& ScriptAssembly::getClass(const String& namespaceName, const String& name)
 	{
+		if(!mIsLoaded)
+			CM_EXCEPT(InvalidStateException, "Trying to use an unloaded assembly.");
+
 		ClassId classId(namespaceName, name);
 		auto iterFind = mClasses.find(classId);
 

CamelotCore/Source/CmScriptClass.cpp → BansheeEngine/Source/BsScriptClass.cpp

@@ -1,9 +1,12 @@
-#include "CmScriptClass.h"
-#include "CmScriptMethod.h"
+#include "BsScriptClass.h"
+#include "BsScriptMethod.h"
+#include "BsScriptField.h"
 #include "CmUtil.h"
 #include "CmException.h"
 
-namespace CamelotFramework
+using namespace CamelotFramework;
+
+namespace BansheeEngine
 {
 	inline size_t ScriptClass::MethodId::Hash::operator()(const ScriptClass::MethodId& v) const
 	{
@@ -38,6 +41,13 @@ namespace CamelotFramework
 		}
 
 		mMethods.clear();
+
+		for(auto& mapEntry : mFields)
+		{
+			cm_delete(mapEntry.second);
+		}
+
+		mFields.clear();
 	}
 
 	ScriptMethod& ScriptClass::getMethod(const String& name, UINT32 numParams)
@@ -60,7 +70,26 @@ namespace CamelotFramework
 		return *newMethod;
 	}
 
-	MonoObject* ScriptClass::invokeMethod(const String& name, ScriptObject* instance, void** params, UINT32 numParams)
+	ScriptField& ScriptClass::getField(const String name)
+	{
+		auto iterFind = mFields.find(name);
+		if(iterFind != mFields.end())
+			return *iterFind->second;
+
+		MonoClassField* field = mono_class_get_field_from_name(mClass, name.c_str());
+		if(field == nullptr)
+		{
+			String fullFieldName = mFullName + "::" + name;
+			CM_EXCEPT(InvalidParametersException, "Cannot get Mono field: " + fullFieldName);
+		}
+
+		ScriptField* newField = new (cm_alloc<ScriptField>()) ScriptField(field);
+		mFields[name] = newField;
+
+		return *newField;
+	}
+
+	MonoObject* ScriptClass::invokeMethod(const String& name, MonoObject* instance, void** params, UINT32 numParams)
 	{
 		return getMethod(name, numParams).invoke(instance, params);
 	}

BansheeEngine/Source/BsScriptField.cpp

@@ -0,0 +1,24 @@
+#include "BsScriptField.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	ScriptField::ScriptField(MonoClassField* field)
+		:mField(field)
+	{
+
+	}
+
+	void* ScriptField::getValue(MonoObject* instance)
+	{
+		void* value;
+		mono_field_get_value(instance, mField, value);
+		return value;
+	}
+
+	void ScriptField::setValue(MonoObject* instance, void* value)
+	{
+		mono_field_set_value(instance, mField, value);
+	}
+}

BansheeEngine/Source/BsScriptManager.cpp

@@ -0,0 +1,101 @@
+#include "BsScriptManager.h"
+#include "CmException.h"
+#include "BsScriptMeta.h"
+#include "BsScriptAssembly.h"
+#include "BsScriptClass.h"
+
+#include <mono/metadata/assembly.h>
+#include <mono/metadata/mono-config.h>
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	const String ScriptManager::DOMAIN_NAME = "BansheeEngine";
+	const String ScriptManager::MONO_LIB_DIR = "..\\..\\Mono\\lib";
+	const String ScriptManager::MONO_ETC_DIR = "..\\..\\Mono\\etc";
+
+	UnorderedMap<String, Vector<ScriptMeta*>::type>::type ScriptManager::mTypesToInitialize;
+
+	ScriptManager::ScriptManager()
+	{
+		mono_set_dirs(MONO_LIB_DIR.c_str(), MONO_ETC_DIR.c_str()); 
+		mono_config_parse(nullptr);
+
+		mDomain = mono_jit_init (DOMAIN_NAME.c_str());
+		if(mDomain == nullptr)
+		{
+			CM_EXCEPT(InternalErrorException, "Cannot initialize Mono runtime.");
+		}
+	}
+
+	ScriptManager::~ScriptManager()
+	{
+		for(auto& entry : mAssemblies)
+		{
+			unloadAssembly(*entry.second);
+			cm_delete(entry.second);
+		}
+
+		mAssemblies.clear();
+
+		if(mDomain != nullptr)
+			mono_jit_cleanup(mDomain);
+	}
+
+	ScriptAssembly& ScriptManager::loadAssembly(const String& path, const String& name)
+	{
+		auto iterFind = mAssemblies.find(name);
+		if(iterFind != mAssemblies.end())
+		{
+			ScriptAssembly* assembly = iterFind->second;
+			if(!assembly->mIsLoaded)
+			{
+				MonoAssembly* monoAssembly = mono_domain_assembly_open (mDomain, path.c_str());
+				if(monoAssembly == nullptr)
+				{
+					CM_EXCEPT(InvalidParametersException, "Cannot load Mono assembly: " + path);
+				}
+
+				assembly->load(monoAssembly);
+			}
+
+			return *iterFind->second;
+		}
+
+		MonoAssembly* monoAssembly = mono_domain_assembly_open (mDomain, path.c_str());
+		if(monoAssembly == nullptr)
+		{
+			CM_EXCEPT(InvalidParametersException, "Cannot load Mono assembly: " + path);
+		}
+
+		ScriptAssembly* assembly = new (cm_alloc<ScriptAssembly>()) ScriptAssembly(monoAssembly);
+		mAssemblies[name] = assembly;
+
+		// Fully initialize all types that use this assembly
+		Vector<ScriptMeta*>::type& mTypeMetas = mTypesToInitialize[name];
+		for(auto& meta : mTypeMetas)
+		{
+			meta->scriptClass = &assembly->getClass(meta->ns, meta->name);
+			meta->thisPtrField = &meta->scriptClass->getField("mCachedPtr");
+			meta->initCallback();
+		}
+
+		return *assembly;
+	}
+
+	void ScriptManager::unloadAssembly(ScriptAssembly& assembly)
+	{
+		MonoAssembly* monoAssembly = assembly.mMonoAssembly;
+		assembly.unload();
+
+		if(monoAssembly)
+			mono_assembly_close(monoAssembly);
+	}
+
+	void ScriptManager::registerScriptType(ScriptMeta* metaData)
+	{
+		Vector<ScriptMeta*>::type& mMetas = mTypesToInitialize[metaData->assembly];
+		mMetas.push_back(metaData);
+	}
+}

BansheeEngine/Source/BsScriptMeta.cpp

@@ -0,0 +1,20 @@
+#include "BsScriptMeta.h"
+#include "BsScriptManager.h"
+#include "BsScriptClass.h"
+#include "BsScriptField.h"
+#include "BsEngineAssembly.h"
+
+namespace BansheeEngine
+{
+	ScriptMeta::ScriptMeta()
+		:scriptClass(nullptr), thisPtrField(nullptr)
+	{
+
+	}
+
+	ScriptMeta::ScriptMeta(const CM::String& assembly, const CM::String& ns, const CM::String& name, std::function<void()> initCallback)
+		:assembly(assembly), ns(ns), name(name), initCallback(initCallback)
+	{
+
+	}
+}

BansheeEngine/Source/BsScriptMethod.cpp

@@ -0,0 +1,23 @@
+#include "BsScriptMethod.h"
+#include "BsScriptObject.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	ScriptMethod::ScriptMethod(MonoMethod* method)
+		:mMethod(method)
+	{
+		mThunk = mono_method_get_unmanaged_thunk(mMethod);
+	}
+
+	MonoObject* ScriptMethod::invoke(MonoObject* instance, void** params)
+	{
+		return mono_runtime_invoke(mMethod, instance, params, nullptr);
+	}		
+
+	void* ScriptMethod::getThunk()
+	{
+		return mThunk;
+	}
+}

BansheeEngine/Source/BsScriptTexture2D.cpp

@@ -0,0 +1,65 @@
+#include "BsScriptTexture2D.h"
+#include "BsScriptMeta.h"
+#include "BsScriptField.h"
+#include "BsScriptClass.h"
+#include "BsScriptManager.h"
+#include "CmTexture.h"
+#include "CmPixelUtil.h"
+#include "CmException.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	ScriptTexture::ScriptTexture(const CM::HTexture& texture)
+		:mTexture(texture)
+	{
+
+	}
+
+	void ScriptTexture::initMetaData()
+	{
+		metaData = ScriptMeta("MBansheeEngine", "BansheeEngine", "Texture2D", &ScriptTexture::initRuntimeData);
+
+		ScriptManager::registerScriptType(&metaData);
+	}
+
+	void ScriptTexture::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptTexture::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptTexture::internal_destroyInstance);
+	}
+
+	void ScriptTexture::internal_createInstance(MonoObject* instance, CM::UINT32 format, CM::UINT32 width, CM::UINT32 height, bool hasMipmaps, bool gammaCorrection)
+	{
+		PixelFormat texFormat = PF_R8G8B8;
+		switch(format)
+		{
+		case 0: // RGB
+			texFormat = PF_R8G8B8;
+			break;
+		case 1: // RGBA
+			texFormat = PF_R8G8B8A8;
+			break;
+		default:
+			CM_EXCEPT(InvalidParametersException, "Unsupported texture format");
+		}
+
+		int numMips = 0;
+		if(hasMipmaps)
+			numMips = PixelUtil::getMaxMipmaps(width, height, 1, texFormat);
+
+		HTexture texture = Texture::create(TEX_TYPE_2D, width, height, numMips, texFormat, TU_STATIC, gammaCorrection);
+
+		ScriptTexture* nativeInstance = new (cm_alloc<ScriptTexture>()) ScriptTexture(texture);
+		nativeInstance->createInstance();
+
+		metaData.thisPtrField->setValue(instance, nativeInstance);
+	}
+
+	void ScriptTexture::internal_destroyInstance(ScriptTexture* nativeInstance)
+	{
+		nativeInstance->destroyInstance();
+		cm_delete(nativeInstance);
+	}
+}

CSharpWrap.txt

@@ -48,28 +48,17 @@ Systems:
 
  -----------------
 
- ScriptManager
- - loadAssembly
- - compileAssembly
-
-ScriptAssembly
- - GetClass(namespace, name)
-
-ScriptClass
- - GetField(name)
- - GetMethod(name)
- - InvokeMethod(name, void** params)
- - AddInternalCall
- - CreateInstance()
-
-ScriptMethod
- - Invoke(void** params)
-
+// TODO - I might need to call this
  retval = mono_jit_exec (domain, assembly, argc - 1, argv + 1);
 to call a Main function in the assembly
 
  -----------------
 
+ Implement ScriptField, EngineAssembly classes
+Implement ScriptClass::getField method
+
+ -----------------
+
  add BansheeEditor class
  Add C++ EditorApplication and have it start up Application and create a main window
 Then in C# class just call EditorApplication to create a main window

CamelotClient/Source/BsEditorApplication.cpp

@@ -4,6 +4,8 @@
 #include "BsApplication.h"
 #include "CmApplication.h"
 #include "CmRenderWindow.h"
+#include "BsScriptManager.h"
+#include "BsEngineAssembly.h"
 
 // DEBUG ONLY
 #include "DbgEditorWidget1.h"
@@ -212,6 +214,8 @@ namespace BansheeEditor
 		/************************************************************************/
 
 		EditorWindowManager::startUp(cm_new<EditorWindowManager>());
+		ScriptManager::startUp(cm_new<ScriptManager>());
+		EngineAssembly::startUp(cm_new<EngineAssembly>());
 		MainEditorWindow* mainWindow = MainEditorWindow::create(gApplication().getPrimaryWindow());
 
 		gApplication().mainLoopCallback.connect(boost::bind(&EditorApplication::update, this));
@@ -221,8 +225,11 @@ namespace BansheeEditor
 
 		gBansheeApp().runMainLoop();
 
+		EngineAssembly::shutDown();
+		ScriptManager::shutDown();
 		EditorWindowManager::shutDown();
 
+
 		/************************************************************************/
 		/* 								DEBUG CODE                      		*/
 		/************************************************************************/

CamelotCore/CamelotCore.vcxproj

@@ -150,7 +150,7 @@
     <Link>
       <SubSystem>NotSet</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>CamelotUtility.lib;mono-2.0.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotUtility.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>../lib/x86/$(Configuration);../Dependencies/lib/x86/Debug</AdditionalLibraryDirectories>
       <ImportLibrary>..\lib\x86\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
@@ -168,7 +168,7 @@
     <Link>
       <SubSystem>NotSet</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>CamelotUtility.lib;mono-2.0.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotUtility.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>../lib/$(Platform)/$(Configuration);../Dependencies/lib/x64/Debug</AdditionalLibraryDirectories>
       <ImportLibrary>..\lib\$(Platform)\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
@@ -192,7 +192,7 @@
       <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>CamelotUtility.lib;mono-2.0.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotUtility.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>../lib/x86/$(Configuration);../Dependencies/lib/x86/Release</AdditionalLibraryDirectories>
       <ImportLibrary>..\lib\x86\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
@@ -217,7 +217,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>CamelotUtility.lib;mono-2.0.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotUtility.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>../lib/x86/$(Configuration);../Dependencies/lib/x86/DebugRelease</AdditionalLibraryDirectories>
       <ImportLibrary>..\lib\x86\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
@@ -241,7 +241,7 @@
       <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>CamelotUtility.lib;mono-2.0.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotUtility.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>../lib/$(Platform)/$(Configuration);../Dependencies/lib/x64/Release</AdditionalLibraryDirectories>
       <ImportLibrary>..\lib\$(Platform)\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
@@ -266,7 +266,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>CamelotUtility.lib;mono-2.0.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CamelotUtility.lib;cg.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories>../lib/$(Platform)/$(Configuration);../Dependencies/lib/x64/DebugRelease</AdditionalLibraryDirectories>
       <ImportLibrary>..\lib\$(Platform)\$(Configuration)\$(TargetName).lib</ImportLibrary>
     </Link>
@@ -346,11 +346,6 @@
     <ClInclude Include="Include\CmOcclusionQuery.h" />
     <ClInclude Include="Include\CmPixelBuffer.h" />
     <ClInclude Include="Include\CmGpuProgIncludeImporter.h" />
-    <ClInclude Include="Include\CmScriptAssembly.h" />
-    <ClInclude Include="Include\CmScriptClass.h" />
-    <ClInclude Include="Include\CmScriptManager.h" />
-    <ClInclude Include="Include\CmScriptMethod.h" />
-    <ClInclude Include="Include\CmScriptObject.h" />
     <ClInclude Include="Include\CmSubMesh.h" />
     <ClInclude Include="Include\CmTextureView.h" />
     <ClInclude Include="Include\CmTextData.h" />
@@ -476,10 +471,6 @@
     <ClCompile Include="Source\CmQueryManager.cpp" />
     <ClCompile Include="Source\CmRenderer.cpp" />
     <ClCompile Include="Source\CmRenderQueue.cpp" />
-    <ClCompile Include="Source\CmScriptAssembly.cpp" />
-    <ClCompile Include="Source\CmScriptClass.cpp" />
-    <ClCompile Include="Source\CmScriptManager.cpp" />
-    <ClCompile Include="Source\CmScriptMethod.cpp" />
     <ClCompile Include="Source\CmTextureView.cpp" />
     <ClCompile Include="Source\CmTextData.cpp" />
     <ClCompile Include="Source\CmTimerQuery.cpp" />

CamelotCore/CamelotCore.vcxproj.filters

@@ -94,12 +94,6 @@
     <Filter Include="Header Files\Platform">
       <UniqueIdentifier>{d53f502a-b966-4162-a828-af2654f0408f}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\Script">
-      <UniqueIdentifier>{85a691b2-e208-4b3f-83e0-d6b7bedb8367}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Script">
-      <UniqueIdentifier>{8e102909-a27d-4961-a4a1-43cb89721afc}</UniqueIdentifier>
-    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Include\CmApplication.h">
@@ -528,21 +522,6 @@
     <ClInclude Include="Include\CmMeshBaseRTTI.h">
       <Filter>Header Files\RTTI</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmScriptManager.h">
-      <Filter>Header Files\Script</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmScriptObject.h">
-      <Filter>Header Files\Script</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmScriptAssembly.h">
-      <Filter>Header Files\Script</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmScriptClass.h">
-      <Filter>Header Files\Script</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmScriptMethod.h">
-      <Filter>Header Files\Script</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmApplication.cpp">
@@ -839,17 +818,5 @@
     <ClCompile Include="Source\CmMeshBase.cpp">
       <Filter>Source Files\Resources</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmScriptMethod.cpp">
-      <Filter>Source Files\Script</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmScriptClass.cpp">
-      <Filter>Source Files\Script</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmScriptAssembly.cpp">
-      <Filter>Source Files\Script</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmScriptManager.cpp">
-      <Filter>Source Files\Script</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>

CamelotCore/Include/CmPixelUtil.h

@@ -163,6 +163,24 @@ namespace CamelotFramework {
         */
         static String getBNFExpressionOfPixelFormats(bool accessibleOnly = false);
 
+		/** Returns the maximum number of Mipmaps that can be generated until we reach
+			the mininum format possible. This does not count the base level.
+			@param width
+				The width of the area
+			@param height
+				The height of the area
+			@param depth
+				The depth of the area
+			@param format
+				The format of the area
+			@remarks
+				In case that the format is non-compressed, this simply returns
+				how many times we can divide this texture in 2 until we reach 1x1.
+				For compressed formats, constraints apply on minimum size and alignment
+				so this might differ.
+		*/
+		static UINT32 getMaxMipmaps(UINT32 width, UINT32 height, UINT32 depth, PixelFormat format);
+
         /** Pack a colour value to memory
         	@param colour	The colour
         	@param pf		Pixelformat in which to write the colour

CamelotCore/Include/CmPrerequisites.h

@@ -132,11 +132,6 @@ namespace CamelotFramework
 	class EventQuery;
 	class TimerQuery;
 	class FrameAlloc;
-	class ScriptManager;
-	class ScriptObject;
-	class ScriptAssembly;
-	class ScriptClass;
-	class ScriptMethod;
 	// Asset import
 	class SpecificImporter;
 	class Importer;

CamelotCore/Include/CmResources.h

@@ -156,7 +156,7 @@ namespace CamelotFramework
 		WorkQueue* mWorkQueue;
 		UINT16 mWorkQueueChannel;
 
-		UnorderedMap<String, HResource>::type mLoadedResources; // TODO Low priority - I'm not sure how will UUID (a string) do as key do performance wise
+		UnorderedMap<String, HResource>::type mLoadedResources; 
 		UnorderedMap<String, ResourceAsyncOp>::type mInProgressResources; // Resources that are being asynchronously loaded
 
 		HResource loadInternal(const String& filePath, bool synchronous); 

CamelotCore/Include/CmScriptAssembly.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "CmPrerequisites.h"
-#include <mono/jit/jit.h>
-#include <mono/metadata/assembly.h>
-
-namespace CamelotFramework
-{
-	class CM_EXPORT ScriptAssembly
-	{
-		struct ClassId
-		{
-			struct Hash
-			{
-				inline size_t operator()(const ClassId& v) const;
-			};
-
-			struct Equals
-			{
-				inline bool operator()(const ClassId &a, const ClassId &b) const;
-			};
-
-			ClassId(const String& namespaceName, String name);
-
-			String namespaceName;
-			String name;
-		};
-
-	public:
-		~ScriptAssembly();
-
-		ScriptClass& getClass(const String& namespaceName, const String& name);
-
-	private:
-		friend class ScriptManager;
-
-		ScriptAssembly(MonoAssembly* assembly);
-
-		MonoImage* mMonoImage;
-		MonoAssembly* mMonoAssembly;
-		UnorderedMap<ClassId, ScriptClass*, ClassId::Hash, ClassId::Equals>::type mClasses;
-	};
-}

CamelotCore/Include/CmScriptClass.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "CmPrerequisites.h"
-#include <mono/jit/jit.h>
-
-namespace CamelotFramework
-{
-	class CM_EXPORT ScriptClass
-	{
-		struct MethodId
-		{
-			struct Hash
-			{
-				inline size_t operator()(const MethodId& v) const;
-			};
-			
-			struct Equals
-			{
-				inline bool operator()(const MethodId &a, const MethodId &b) const;
-			};
-
-			MethodId(const String& name, UINT32 numParams);
-
-			String name;
-			UINT32 numParams;
-		};
-
-	public:
-		~ScriptClass();
-
-		ScriptMethod& getMethod(const String& name, UINT32 numParams = 0);
-		
-		MonoObject* invokeMethod(const String& name, ScriptObject* instance = nullptr, void** params = nullptr, UINT32 numParams = 0);
-		void addInternalCall(const String& name, const void* method);
-	private:
-		friend class ScriptAssembly;
-
-		ScriptClass(const String& fullName, MonoClass* monoClass);
-
-		MonoClass* mClass;
-		String mFullName;
-
-		UnorderedMap<MethodId, ScriptMethod*, MethodId::Hash, MethodId::Equals>::type mMethods; 
-	};
-}

CamelotCore/Include/CmScriptManager.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include "CmPrerequisites.h"
-#include "CmModule.h"
-#include <mono/jit/jit.h>
-
-namespace CamelotFramework
-{
-	/**
-	 * @brief	Loads Mono script assemblies and manages script objects.
-	 */
-	class CM_EXPORT ScriptManager : public Module<ScriptManager>
-	{
-	public:
-		ScriptManager();
-		~ScriptManager();
-
-		ScriptAssembly& loadAssembly(const String& name);
-
-		MonoDomain* getDomain() const { return mDomain; }
-
-	private:
-		static const String DOMAIN_NAME;
-		static const String MONO_LIB_DIR;
-		static const String MONO_ETC_DIR;
-
-		MonoDomain* mDomain;
-		UnorderedMap<String, ScriptAssembly*>::type mAssemblies;
-	};
-}

CamelotCore/Include/CmScriptObject.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include "CmPrerequisites.h"
-#include <mono/jit/jit.h>
-
-namespace CamelotFramework
-{
-	/**
-	 * @brief	 Base class for objects that can be extended using Mono scripting
-	 */
-	class CM_EXPORT ScriptObject
-	{
-	public:
-		class CM_EXPORT Meta
-		{
-			const char* Namespace;								
-			const char* Name;									
-			MonoClass* Class;									
-			MonoDomain* Domain;									
-			MonoClassField* ThisPtr;	
-
-			virtual void init() = 0;
-		};
-
-		virtual void script_create(MonoObject* scriptObj) = 0;
-		virtual void script_destroy() = 0;
-
-		MonoObject* getMonoObject() const { return mScriptObject; }
-	private:
-		MonoObject* mScriptObject;	
-	};
-}

CamelotCore/Source/CmPixelUtil.cpp

@@ -1014,6 +1014,29 @@ namespace CamelotFramework {
 
         return result;
     }
+
+	UINT32 PixelUtil::getMaxMipmaps(UINT32 width, UINT32 height, UINT32 depth, PixelFormat format)
+	{
+		UINT32 count = 0;
+        if((width > 0) && (height > 0))
+        {
+            do {
+                if(width>1)		width = width/2;
+                if(height>1)	height = height/2;
+                if(depth>1)		depth = depth/2;
+                /*
+                NOT needed, compressed formats will have mipmaps up to 1x1
+                if(PixelUtil::isValidExtent(width, height, depth, format))
+                    count ++;
+                else
+                    break;
+                */
+                    
+                count ++;
+            } while(!(width == 1 && height == 1 && depth == 1));
+        }		
+		return count;
+	}
     //-----------------------------------------------------------------------
     /*************************************************************************
     * Pixel packing/unpacking utilities

CamelotCore/Source/CmScriptManager.cpp

@@ -1,58 +0,0 @@
-#include "CmScriptManager.h"
-#include "CmException.h"
-#include "CmScriptAssembly.h"
-
-#include <mono/metadata/assembly.h>
-#include <mono/metadata/mono-config.h>
-
-namespace CamelotFramework
-{
-	const String ScriptManager::DOMAIN_NAME = "BansheeEngine";
-	const String ScriptManager::MONO_LIB_DIR = "..\\..\\Mono\\lib";
-	const String ScriptManager::MONO_ETC_DIR = "..\\..\\Mono\\etc";
-
-	ScriptManager::ScriptManager()
-	{
-		mono_set_dirs(MONO_LIB_DIR.c_str(), MONO_ETC_DIR.c_str()); 
-		mono_config_parse(nullptr);
-
-		mDomain = mono_jit_init (DOMAIN_NAME.c_str());
-		if(mDomain == nullptr)
-		{
-			CM_EXCEPT(InternalErrorException, "Cannot initialize Mono runtime.");
-		}
-	}
-
-	ScriptManager::~ScriptManager()
-	{
-		for(auto& entry : mAssemblies)
-		{
-			cm_delete(entry.second);
-		}
-
-		mAssemblies.clear();
-
-		if(mDomain != nullptr)
-			mono_jit_cleanup(mDomain);
-	}
-
-	ScriptAssembly& ScriptManager::loadAssembly(const String& name)
-	{
-		auto iterFind = mAssemblies.find(name);
-		if(iterFind != mAssemblies.end())
-		{
-			return *iterFind->second;
-		}
-
-		MonoAssembly* monoAssembly = mono_domain_assembly_open (mDomain, name.c_str());
-		if(monoAssembly == nullptr)
-		{
-			CM_EXCEPT(InvalidParametersException, "Cannot load Mono assembly: " + name);
-		}
-
-		ScriptAssembly* assembly = new (cm_alloc<ScriptAssembly>()) ScriptAssembly(monoAssembly);
-		mAssemblies[name] = assembly;
-
-		return *assembly;
-	}
-}

CamelotCore/Source/CmScriptMethod.cpp

@@ -1,21 +0,0 @@
-#include "CmScriptMethod.h"
-#include "CmScriptObject.h"
-
-namespace CamelotFramework
-{
-	ScriptMethod::ScriptMethod(MonoMethod* method)
-		:mMethod(method)
-	{
-		mThunk = mono_method_get_unmanaged_thunk(mMethod);
-	}
-
-	MonoObject* ScriptMethod::invoke(ScriptObject* instance, void** params)
-	{
-		return mono_runtime_invoke(mMethod, instance->getMonoObject(), params, nullptr);
-	}		
-
-	void* ScriptMethod::getThunk()
-	{
-		return mThunk;
-	}
-}

CamelotGLRenderer/Include/CmGLPixelFormat.h

@@ -88,25 +88,7 @@ namespace CamelotFramework {
 		 *
 		 */
 		static GLenum getBaseFormatFromCompressedInternalFormat(GLenum internalFormat);
-	
-		/** Returns the maximum number of Mipmaps that can be generated until we reach
-			the mininum format possible. This does not count the base level.
-			@param width
-				The width of the area
-			@param height
-				The height of the area
-			@param depth
-				The depth of the area
-			@param format
-				The format of the area
-			@remarks
-				In case that the format is non-compressed, this simply returns
-				how many times we can divide this texture in 2 until we reach 1x1.
-				For compressed formats, constraints apply on minimum size and alignment
-				so this might differ.
-		*/
-		static UINT32 getMaxMipmaps(UINT32 width, UINT32 height, UINT32 depth, PixelFormat format);
-        
+	        
         /** Returns next power-of-two size if required by render system, in case
             RSC_NON_POWER_OF_2_TEXTURES is supported it returns value as-is.
         */

CamelotGLRenderer/Source/CmGLPixelFormat.cpp

@@ -342,29 +342,6 @@ namespace CamelotFramework  {
 			return PF_UNKNOWN;
 		}
 	}
-	//----------------------------------------------------------------------------- 
-	UINT32 GLPixelUtil::getMaxMipmaps(UINT32 width, UINT32 height, UINT32 depth, PixelFormat format)
-	{
-		UINT32 count = 0;
-        if((width > 0) && (height > 0))
-        {
-            do {
-                if(width>1)		width = width/2;
-                if(height>1)	height = height/2;
-                if(depth>1)		depth = depth/2;
-                /*
-                NOT needed, compressed formats will have mipmaps up to 1x1
-                if(PixelUtil::isValidExtent(width, height, depth, format))
-                    count ++;
-                else
-                    break;
-                */
-                    
-                count ++;
-            } while(!(width == 1 && height == 1 && depth == 1));
-        }		
-		return count;
-	}
     //-----------------------------------------------------------------------------    
     UINT32 GLPixelUtil::optionalPO2(UINT32 value)
     {

CamelotGLRenderer/Source/CmGLTexture.cpp

@@ -63,7 +63,7 @@ namespace CamelotFramework {
 	void GLTexture::initialize_internal()
 	{
 		// Check requested number of mipmaps
-		UINT32 maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
+		UINT32 maxMips = PixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
 		if(mNumMipmaps > maxMips)
 			CM_EXCEPT(InvalidParametersException, "Invalid number of mipmaps. Maximum allowed is: " + toString(maxMips));
 

MBansheeEditor/MBansheeEditor.csproj

@@ -16,7 +16,7 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
+    <OutputPath>..\bin\Assemblies\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
@@ -24,7 +24,7 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
+    <OutputPath>..\bin\Assemblies\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>

MBansheeEngine/Application.cs

@@ -1,10 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace BansheeEngine
-{
-    public class Application
-    {
-
-    }
-}

MBansheeEngine/MBansheeEngine.csproj

@@ -9,14 +9,15 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>MBansheeEngine</RootNamespace>
     <AssemblyName>MBansheeEngine</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
+    <OutputPath>..\bin\Assemblies\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
@@ -24,7 +25,7 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
+    <OutputPath>..\bin\Assemblies\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
@@ -39,9 +40,11 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Application.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ScriptObject.cs" />
+    <Compile Include="Texture2D.cs" />
+    <Compile Include="TextureFormat.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

MBansheeEngine/ScriptObject.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BansheeEngine
+{
+    public class ScriptObject
+    {
+        protected IntPtr mCachedPtr;
+    }
+}

MBansheeEngine/Texture2D.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BansheeEngine
+{
+    public sealed class Texture2D : ScriptObject
+    {
+        public Texture2D(TextureFormat format, int width, int height, bool hasMipmaps = false, bool gammaCorrection = false)
+        {
+            Internal_CreateInstance(this, format, width, height, hasMipmaps, gammaCorrection);
+        }
+
+        ~Texture2D()
+        {
+            Internal_DestroyInstance(mCachedPtr);
+        }
+
+        [DllImport("__Internal")]
+        private static extern void Internal_CreateInstance(Texture2D instance, TextureFormat format, int width, int height, bool hasMipmaps, bool gammaCorrection);
+
+        [DllImport("__Internal")]
+        private static extern void Internal_DestroyInstance(IntPtr nativeInstance);
+    }
+}

MBansheeEngine/TextureFormat.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BansheeEngine
+{
+    // TODO - Add more formats
+    public enum TextureFormat
+    {
+        RGB,
+        RGBA
+    }
+}