Moved all Script stuff to separate libraries #4

BansheeEngine/Include/BsScriptClass.h

@@ -1,52 +0,0 @@
-#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);
-		ScriptProperty& getProperty(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);
-
-		MonoObject* createInstance() const;
-	private:
-		friend class ScriptAssembly;
-
-		ScriptClass(const CM::String& fullName, MonoClass* monoClass, ScriptAssembly* parentAssembly);
-
-		ScriptAssembly* mParentAssembly;
-		MonoClass* mClass;
-		CM::String mFullName;
-
-		CM::UnorderedMap<MethodId, ScriptMethod*, MethodId::Hash, MethodId::Equals>::type mMethods; 
-		CM::UnorderedMap<CM::String, ScriptField*>::type mFields; 
-		CM::UnorderedMap<CM::String, ScriptProperty*>::type mProperties;
-	};
-}

BansheeEngine/Include/BsScriptField.h

@@ -1,23 +0,0 @@
-#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

@@ -1,35 +0,0 @@
-#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, const CM::String& entryPoint = CM::StringUtil::BLANK);
-		void unloadAssembly(ScriptAssembly& assembly);
-
-		static void registerScriptType(ScriptMeta* metaData);
-	private:
-		static const CM::String MONO_LIB_DIR;
-		static const CM::String MONO_ETC_DIR;
-
-		static CM::UnorderedMap<CM::String, CM::Vector<ScriptMeta*>::type>::type& getTypesToInitialize()
-		{
-			static CM::UnorderedMap<CM::String, CM::Vector<ScriptMeta*>::type>::type mTypesToInitialize;
-			return mTypesToInitialize;
-		}
-
-		CM::UnorderedMap<CM::String, ScriptAssembly*>::type mAssemblies;
-	};
-}

BansheeEngine/Include/BsScriptMethod.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_EXPORT ScriptMethod
-	{
-	public:
-		MonoObject* invoke(MonoObject* instance, void** params);
-
-		/**
-		 * @brief	Gets a thunk for this method. A thunk is a C++ like function
-		 * 			pointer that you can use for calling the method.
-		 *
-		 * @note	This is the fastest way of calling managed code.
-		 */
-		void* getThunk() const;
-
-		CM::String getName() const;
-
-	private:
-		friend class ScriptClass;
-		friend class ScriptProperty;
-
-		ScriptMethod(MonoMethod* method);
-
-		MonoMethod* mMethod;
-		void* mThunk;
-	};
-}

BansheeEngine/Include/BsScriptProperty.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include <mono/jit/jit.h>
-
-namespace BansheeEngine
-{
-	class BS_EXPORT ScriptProperty
-	{
-	public:
-		MonoObject* get(MonoObject* instance) const;
-		void set(MonoObject* instance, MonoObject* value) const;
-
-	private:
-		friend class ScriptClass;
-
-		ScriptProperty(MonoProperty* monoProp);
-
-		MonoProperty* mProperty;
-		MonoMethod* mGetMethod;
-		MonoMethod* mSetMethod;
-	};
-}

BansheeEngine/Source/BsScriptClass.cpp

@@ -1,138 +0,0 @@
-#include "BsScriptClass.h"
-#include "BsScriptMethod.h"
-#include "BsScriptField.h"
-#include "BsScriptProperty.h"
-#include "BsScriptAssembly.h"
-#include "BsScriptManager.h"
-#include "CmUtil.h"
-#include "CmException.h"
-
-using namespace CamelotFramework;
-
-namespace BansheeEngine
-{
-	inline size_t ScriptClass::MethodId::Hash::operator()(const ScriptClass::MethodId& v) const
-	{
-		size_t seed = 0;
-		hash_combine(seed, v.name);
-		hash_combine(seed, v.numParams);
-		return seed;
-	}
-
-	inline bool ScriptClass::MethodId::Equals::operator()(const ScriptClass::MethodId &a, const ScriptClass::MethodId &b) const
-	{
-		return a.name == b.name && a.numParams == b.numParams;
-	}
-
-	ScriptClass::MethodId::MethodId(const String& name, UINT32 numParams)
-		:name(name), numParams(numParams)
-	{
-
-	}
-
-	ScriptClass::ScriptClass(const String& fullName, MonoClass* monoClass, ScriptAssembly* parentAssembly)
-		:mFullName(fullName), mClass(monoClass), mParentAssembly(parentAssembly)
-	{
-
-	}
-
-	ScriptClass::~ScriptClass()
-	{
-		for(auto& mapEntry : mMethods)
-		{
-			cm_delete(mapEntry.second);
-		}
-
-		mMethods.clear();
-
-		for(auto& mapEntry : mFields)
-		{
-			cm_delete(mapEntry.second);
-		}
-
-		mFields.clear();
-
-		for(auto& mapEntry : mProperties)
-		{
-			cm_delete(mapEntry.second);
-		}
-
-		mProperties.clear();
-	}
-
-	ScriptMethod& ScriptClass::getMethod(const String& name, UINT32 numParams)
-	{
-		MethodId mehodId(name, numParams);
-		auto iterFind = mMethods.find(mehodId);
-		if(iterFind != mMethods.end())
-			return *iterFind->second;
-
-		MonoMethod* method = mono_class_get_method_from_name(mClass, name.c_str(), (int)numParams);
-		if(method == nullptr)
-		{
-			String fullMethodName = mFullName + "::" + name;
-			CM_EXCEPT(InvalidParametersException, "Cannot get Mono method: " + fullMethodName);
-		}
-
-		ScriptMethod* newMethod = new (cm_alloc<ScriptMethod>()) ScriptMethod(method);
-		mMethods[mehodId] = newMethod;
-
-		return *newMethod;
-	}
-
-	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;
-	}
-
-	ScriptProperty& ScriptClass::getProperty(const String& name)
-	{
-		auto iterFind = mProperties.find(name);
-		if(iterFind != mProperties.end())
-			return *iterFind->second;
-
-		MonoProperty* property = mono_class_get_property_from_name(mClass, name.c_str());
-		if(property == nullptr)
-		{
-			String fullPropertyName = mFullName + "::" + name;
-			CM_EXCEPT(InvalidParametersException, "Cannot get Mono property: " + fullPropertyName);
-		}
-
-		ScriptProperty* newProperty = new (cm_alloc<ScriptProperty>()) ScriptProperty(property);
-		mProperties[name] = newProperty;
-
-		return *newProperty;
-	}
-
-	MonoObject* ScriptClass::invokeMethod(const String& name, MonoObject* instance, void** params, UINT32 numParams)
-	{
-		return getMethod(name, numParams).invoke(instance, params);
-	}
-
-	void ScriptClass::addInternalCall(const String& name, const void* method)
-	{
-		String fullMethodName = mFullName + "::" + name;
-		mono_add_internal_call(fullMethodName.c_str(), method);
-	}
-
-	MonoObject* ScriptClass::createInstance() const
-	{
-		MonoObject* obj = mono_object_new(mParentAssembly->getDomain(), mClass);
-
-		return obj;
-	}
-}

BansheeEngine/Source/BsScriptField.cpp

@@ -1,24 +0,0 @@
-#include "BsScriptField.h"
-
-using namespace CamelotFramework;
-
-namespace BansheeEngine
-{
-	ScriptField::ScriptField(MonoClassField* field)
-		:mField(field)
-	{
-
-	}
-
-	void* ScriptField::getValue(MonoObject* instance)
-	{
-		void* value = nullptr;
-		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

@@ -1,82 +0,0 @@
-#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::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);
-	}
-
-	ScriptManager::~ScriptManager()
-	{
-		for(auto& entry : mAssemblies)
-		{
-			unloadAssembly(*entry.second);
-			cm_delete(entry.second);
-		}
-
-		mAssemblies.clear();
-	}
-
-	ScriptAssembly& ScriptManager::loadAssembly(const String& path, const String& name, const String& entryPoint)
-	{
-		ScriptAssembly* assembly = nullptr;
-
-		auto iterFind = mAssemblies.find(name);
-		if(iterFind != mAssemblies.end())
-		{
-			assembly = iterFind->second;
-		}
-		else
-		{
-			assembly = new (cm_alloc<ScriptAssembly>()) ScriptAssembly();
-			mAssemblies[name] = assembly;
-		}
-
-		if(!assembly->mIsLoaded)
-		{
-			assembly->load(path, name);
-
-			// Fully initialize all types that use this assembly
-			Vector<ScriptMeta*>::type& mTypeMetas = getTypesToInitialize()[name];
-			for(auto& meta : mTypeMetas)
-			{
-				meta->scriptClass = &assembly->getClass(meta->ns, meta->name);
-				meta->thisPtrField = &meta->scriptClass->getField("mCachedPtr");
-				meta->initCallback();
-			}
-
-			assembly->initialize(entryPoint); // Perform any initialization after everything is loaded
-		}
-
-		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 = getTypesToInitialize()[metaData->assembly];
-		mMetas.push_back(metaData);
-	}
-}

BansheeEngine/Source/BsScriptMethod.cpp

@@ -1,28 +0,0 @@
-#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() const
-	{
-		return mThunk;
-	}
-
-	String ScriptMethod::getName() const
-	{
-		return String(mono_method_get_name(mMethod));
-	}
-}

BansheeEngine/Source/BsScriptProperty.cpp

@@ -1,27 +0,0 @@
-#include "BsScriptProperty.h"
-#include "BsScriptObject.h"
-#include "BsScriptMethod.h"
-
-using namespace CamelotFramework;
-
-namespace BansheeEngine
-{
-	ScriptProperty::ScriptProperty(MonoProperty* monoProp)
-		:mProperty(monoProp)
-	{
-		mGetMethod = mono_property_get_get_method(mProperty);
-		mSetMethod = mono_property_get_set_method(mProperty);
-	}
-
-	MonoObject* ScriptProperty::get(MonoObject* instance) const
-	{
-		return mono_runtime_invoke(mGetMethod, instance, nullptr, nullptr);
-	}
-
-	void ScriptProperty::set(MonoObject* instance, MonoObject* value) const
-	{
-		void* args[1];
-		args[0] = value;
-		mono_runtime_invoke(mSetMethod, instance, args, nullptr);
-	}	
-}