WIP C# ProjectLibrary and ImportOptions

MBansheeEditor/ProjectLibrary.cs

@@ -9,6 +9,9 @@ namespace BansheeEditor
     {
         public static DirectoryEntry Root { get { return Internal_GetRoot(); } }
 
+        public static event Action<string> OnEntryAdded;
+        public static event Action<string> OnEntryRemoved;
+
         public static void Create(Resource resource, string path)
         {
             if (Path.IsPathRooted(path))
@@ -75,6 +78,18 @@ namespace BansheeEditor
             Internal_Copy(source, destination, overwrite);
         }
 
+        private static void Internal_DoOnEntryAdded(string path)
+        {
+            if (OnEntryAdded != null)
+                OnEntryAdded(path);
+        }
+
+        private static void Internal_DoOnEntryRemoved(string path)
+        {
+            if (OnEntryRemoved != null)
+                OnEntryRemoved(path);
+        }
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_Create(Resource resource, string path);
 
@@ -112,103 +127,64 @@ namespace BansheeEditor
         private static extern void Internal_Copy(string source, string destination, bool overwrite);
     }
 
+    // Note: Must be the same as C++ enum ProjectLibrary::LibraryEntryType
     public enum LibraryEntryType
     {
         File, Directory
     }
 
+    // Note: Must be the same as C++ enum ScriptResourceType
     public enum ResourceType
     {
-        Texture, SpriteTexture, Mesh, Font, GUISkin
+        Texture, SpriteTexture, Mesh, Font, GpuProgram, Undefined
     }
 
     public class LibraryEntry : ScriptObject
     {
-        public String Path
-        {
-            get
-            {
-                // TODO
-                return "";
-            }
-        }
+        public string Path { get { return Internal_GetPath(mCachedPtr); } }
+        public string Name { get { return Internal_GetName(mCachedPtr); } }
 
-        public String Name
-        {
-            get
-            {
-                // TODO
-                return "";
-            }
-        }
+        public LibraryEntryType Type { get { return Internal_GetType(mCachedPtr); } }
+        public DirectoryEntry Parent { get { return Internal_GetParent(mCachedPtr); } }
 
-        public LibraryEntryType Type
-        {
-            get
-            {
-                // TODO
-                return LibraryEntryType.File;
-            }
-        }
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string Internal_GetPath(IntPtr thisPtr);
 
-        public DirectoryEntry Parent
-        {
-            get
-            {
-                // TODO
-                return null;
-            }
-        }
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string Internal_GetName(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern LibraryEntryType Internal_GetType(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern DirectoryEntry Internal_GetParent(IntPtr thisPtr);
     }
 
     public class DirectoryEntry : LibraryEntry
     {
-        public LibraryEntry[] Children
-        {
-            get
-            {
-                // TODO
-                return null;
-            }
-        }
+        public LibraryEntry[] Children { get { return Internal_GetChildren(mCachedPtr); } }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern LibraryEntry[] Internal_GetChildren(IntPtr thisPtr);
     }
 
     public class FileEntry : LibraryEntry
     {
-        public ImportOptions Options
-        {
-            get
-            {
-                // TODO
-                return null;
-            }
-        }
+        public ImportOptions Options { get { return Internal_GetImportOptions(mCachedPtr); } }
+        public string UUID { get { return Internal_GetUUID(mCachedPtr); } }
+        public Texture2D Icon { get { return Internal_GetIcon(mCachedPtr); } }
+        public ResourceType ResType { get { return Internal_GetResourceType(mCachedPtr); } }
 
-        public string UUID
-        {
-            get
-            {
-                // TODO
-                return "";
-            }
-        }
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern ImportOptions Internal_GetImportOptions(IntPtr thisPtr);
 
-        public Texture2D Icon
-        {
-            get
-            {
-                // TODO
-                return null;
-            }
-        }
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string Internal_GetUUID(IntPtr thisPtr);
 
-        public ResourceType ResType
-        {
-            get
-            {
-                // TODO
-                return ResourceType.Texture;
-            }
-        }
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Texture2D Internal_GetIcon(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern ResourceType Internal_GetResourceType(IntPtr thisPtr);
     }
 }

SBansheeEditor/Include/BsScriptImportOptions.h

@@ -6,14 +6,45 @@
 
 namespace BansheeEngine
 {
-	class BS_SCR_BED_EXPORT ScriptTextureImportOptions : public ScriptObject<ScriptTextureImportOptions>
+	class BS_SCR_BED_EXPORT ScriptImportOptionsBase : ScriptObjectBase
+	{
+	public:
+		SPtr<ImportOptions> getImportOptions() const { return mImportOptions; }
+
+	protected:
+		ScriptImportOptionsBase(MonoObject* instance);
+		virtual ~ScriptImportOptionsBase() {}
+
+		SPtr<ImportOptions> mImportOptions;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptImportOptions : public ScriptObject <ScriptImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		static String getAssemblyName() { return BansheeEditorAssemblyName; }
+		static String getNamespace() { return "BansheeEditor"; }
+		static String getTypeName() { return "ImportOptions"; }
+		static void initRuntimeData() { }
+
+		static MonoObject* create(const SPtr<ImportOptions>& importOptions);
+
+	private:
+		ScriptImportOptions(MonoObject* instance)
+			:ScriptObject(instance)
+		{ }
+	};
+
+	class BS_SCR_BED_EXPORT ScriptTextureImportOptions : public ScriptObject<ScriptTextureImportOptions, ScriptImportOptionsBase>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "TextureImportOptions")
 
 		static MonoObject* create();
+		static MonoObject* create(const SPtr<TextureImportOptions>& options);
 
 	private:
+		SPtr<TextureImportOptions> getTexImportOptions();
+
 		static void internal_CreateInstance(MonoObject* instance);
 		static PixelFormat internal_GetPixelFormat(ScriptTextureImportOptions* thisPtr);
 		static void internal_SetPixelFormat(ScriptTextureImportOptions* thisPtr, PixelFormat value);
@@ -23,18 +54,19 @@ namespace BansheeEngine
 		static void internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value);
 
 		ScriptTextureImportOptions(MonoObject* instance);
-
-		SPtr<TextureImportOptions> mImportOptions;
 	};
 
-	class BS_SCR_BED_EXPORT ScriptFontImportOptions : public ScriptObject <ScriptFontImportOptions>
+	class BS_SCR_BED_EXPORT ScriptFontImportOptions : public ScriptObject <ScriptFontImportOptions, ScriptImportOptionsBase>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "FontImportOptions")
 
 		static MonoObject* create();
+		static MonoObject* create(const SPtr<FontImportOptions>& options);
 
 	private:
+		SPtr<FontImportOptions> getFontImportOptions();
+
 		static void internal_CreateInstance(MonoObject* instance);
 		static MonoArray* internal_GetFontSizes(ScriptFontImportOptions* thisPtr);
 		static void internal_SetFontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value);
@@ -46,18 +78,19 @@ namespace BansheeEngine
 		static void internal_SetCharRanges(ScriptFontImportOptions* thisPtr, MonoArray* value);
 
 		ScriptFontImportOptions(MonoObject* instance);
-
-		SPtr<FontImportOptions> mImportOptions;
 	};
 
-	class BS_SCR_BED_EXPORT ScriptGpuProgramImportOptions : public ScriptObject <ScriptGpuProgramImportOptions>
+	class BS_SCR_BED_EXPORT ScriptGpuProgramImportOptions : public ScriptObject <ScriptGpuProgramImportOptions, ScriptImportOptionsBase>
 	{
 	public:
 		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GpuProgramImportOptions")
 
 		static MonoObject* create();
+		static MonoObject* create(const SPtr<GpuProgramImportOptions>& options);
 
 	private:
+		SPtr<GpuProgramImportOptions> getGpuProgImportOptions();
+
 		static void internal_CreateInstance(MonoObject* instance);
 		static MonoString* internal_GetEntryPoint(ScriptGpuProgramImportOptions* thisPtr);
 		static void internal_SetEntryPoint(ScriptGpuProgramImportOptions* thisPtr, MonoString* value);
@@ -69,8 +102,6 @@ namespace BansheeEngine
 		static void internal_SetType(ScriptGpuProgramImportOptions* thisPtr, GpuProgramType value);
 
 		ScriptGpuProgramImportOptions(MonoObject* instance);
-
-		SPtr<GpuProgramImportOptions> mImportOptions;
 	};
 
 	class BS_SCR_BED_EXPORT ScriptCharRange : public ScriptObject <ScriptCharRange>

SBansheeEditor/Include/BsScriptProjectLibrary.h

@@ -2,7 +2,8 @@
 
 #include "BsScriptEditorPrerequisites.h"
 #include "BsScriptObject.h"
-#include "BsStringTable.h"
+#include "BsProjectLibrary.h"
+#include "BsScriptResource.h"
 
 namespace BansheeEngine
 {
@@ -11,6 +12,9 @@ namespace BansheeEngine
 	public:
 		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "ProjectLibrary")
 
+		void static startUp();
+		void static shutDown();
+
 	private:
 		static void internal_Create(MonoObject* resource, MonoString* path);
 		static MonoObject* internal_Load(MonoString* path);
@@ -25,6 +29,70 @@ namespace BansheeEngine
 		static void internal_Move(MonoString* oldPath, MonoString* newPath, bool overwrite);
 		static void internal_Copy(MonoString* source, MonoString* destination, bool overwrite);
 
+		static void onEntryAdded(const Path& path);
+		static void onEntryRemoved(const Path& path);
+
 		ScriptProjectLibrary(MonoObject* instance);
+
+		typedef void(__stdcall *OnEntryChangedThunkDef) (MonoString*, MonoException**);
+
+		static OnEntryChangedThunkDef OnEntryAddedThunk;
+		static OnEntryChangedThunkDef OnEntryRemovedThunk;
+
+		static HEvent mOnEntryAddedConn;
+		static HEvent mOnEntryRemovedConn;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptLibraryEntryBase : public ScriptObjectBase
+	{
+	public:
+		const Path& getAssetPath() const { return mAssetPath; }
+
+	protected:
+		ScriptLibraryEntryBase(MonoObject* instance);
+		virtual ~ScriptLibraryEntryBase() {}
+
+		Path mAssetPath;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptLibraryEntry : public ScriptObject <ScriptLibraryEntry>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "LibraryEntry")
+
+	private:
+		static MonoString* internal_GetPath(ScriptLibraryEntryBase* thisPtr);
+		static MonoString* internal_GetName(ScriptLibraryEntryBase* thisPtr);
+		static ProjectLibrary::LibraryEntryType internal_GetType(ScriptLibraryEntryBase* thisPtr);
+		static MonoObject* internal_GetParent(ScriptLibraryEntryBase* thisPtr);
+	};
+
+	class BS_SCR_BED_EXPORT ScriptDirectoryEntry : public ScriptObject <ScriptDirectoryEntry, ScriptLibraryEntryBase>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "DirectoryEntry")
+
+		ScriptDirectoryEntry(MonoObject* instance, const Path& assetPath);
+
+		static MonoObject* create(const ProjectLibrary::DirectoryEntry* entry);
+
+	private:
+		static MonoArray* internal_GetChildren(ScriptDirectoryEntry* thisPtr);
+	};
+
+	class BS_SCR_BED_EXPORT ScriptFileEntry : public ScriptObject <ScriptFileEntry, ScriptLibraryEntryBase>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "FileEntry")
+
+		ScriptFileEntry(MonoObject* instance, const Path& assetPath);
+
+		static MonoObject* create(const ProjectLibrary::ResourceEntry* entry);
+
+	private:
+		static MonoObject* internal_GetImportOptions(ScriptFileEntry* thisPtr);
+		static MonoString* internal_GetUUID(ScriptFileEntry* thisPtr);
+		static MonoObject* internal_GetIcon(ScriptFileEntry* thisPtr);
+		static ScriptResourceType internal_GetResourceType(ScriptFileEntry* thisPtr);
 	};
 }

SBansheeEditor/Source/BsEditorScriptManager.cpp

@@ -9,6 +9,7 @@
 #include "BsScriptHandleManager.h"
 #include "BsScriptHandleSliderManager.h"
 #include "BsScriptDragDropManager.h"
+#include "BsScriptProjectLibrary.h"
 #include "BsTime.h"
 #include "BsMath.h"
 
@@ -27,6 +28,7 @@ namespace BansheeEngine
 		ScriptGizmoManager::startUp(ScriptAssemblyManager::instance());
 		HandleManager::startUp<ScriptHandleManager>(ScriptAssemblyManager::instance());
 		ScriptDragDropManager::startUp();
+		ScriptProjectLibrary::startUp();
 
 		mOnDomainLoadConn = ScriptObjectManager::instance().onRefreshDomainLoaded.connect(std::bind(&EditorScriptManager::loadMonoTypes, this));
 		mOnAssemblyRefreshDoneConn = ScriptObjectManager::instance().onRefreshComplete.connect(std::bind(&EditorScriptManager::onAssemblyRefreshDone, this));
@@ -42,6 +44,7 @@ namespace BansheeEngine
 		mOnDomainLoadConn.disconnect();
 		mOnAssemblyRefreshDoneConn.disconnect();
 
+		ScriptProjectLibrary::shutDown();
 		ScriptDragDropManager::shutDown();
 		ScriptHandleSliderManager::shutDown();
 		HandleManager::shutDown();

SBansheeEditor/Source/BsScriptImportOptions.cpp

@@ -9,6 +9,7 @@
 #include "BsFontImportOptions.h"
 #include "BsGpuProgramImportOptions.h"
 #include "BsRenderer.h"
+#include "BsRTTIType.h"
 
 using namespace std::placeholders;
 
@@ -26,10 +27,33 @@ namespace BansheeEngine
 	void ScriptCharRange::initRuntimeData()
 	{ }
 
-	ScriptTextureImportOptions::ScriptTextureImportOptions(MonoObject* instance)
-		:ScriptObject(instance), mImportOptions(bs_shared_ptr<TextureImportOptions>())
+	ScriptImportOptionsBase::ScriptImportOptionsBase(MonoObject* instance)
+		:ScriptObjectBase(instance)
+	{ }
+
+	MonoObject* ScriptImportOptions::create(const SPtr<ImportOptions>& importOptions)
 	{
+		UINT32 typeId = importOptions->getRTTI()->getRTTIId();
+		switch (typeId)
+		{
+		case TID_TextureImportOptions:
+			return ScriptTextureImportOptions::create(std::static_pointer_cast<TextureImportOptions>(importOptions));
+			break;
+		case TID_FontImportOptions:
+			return ScriptFontImportOptions::create(std::static_pointer_cast<FontImportOptions>(importOptions));
+			break;
+		case TID_GpuProgramImportOptions:
+			return ScriptGpuProgramImportOptions::create(std::static_pointer_cast<GpuProgramImportOptions>(importOptions));
+			break;
+		}
 
+		return nullptr;
+	}
+
+	ScriptTextureImportOptions::ScriptTextureImportOptions(MonoObject* instance)
+		:ScriptObject(instance)
+	{
+		mImportOptions = bs_shared_ptr<TextureImportOptions>();
 	}
 
 	void ScriptTextureImportOptions::initRuntimeData()
@@ -43,11 +67,25 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_SetMaxMipmapLevel", &ScriptTextureImportOptions::internal_SetMaxMipmapLevel);
 	}
 
+	SPtr<TextureImportOptions> ScriptTextureImportOptions::getTexImportOptions()
+	{
+		return std::static_pointer_cast<TextureImportOptions>(mImportOptions);
+	}
+
 	MonoObject* ScriptTextureImportOptions::create()
 	{
 		return metaData.scriptClass->createInstance();
 	}
 
+	MonoObject* ScriptTextureImportOptions::create(const SPtr<TextureImportOptions>& options)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		ScriptTextureImportOptions* scriptObj = ScriptTextureImportOptions::toNative(managedInstance);
+		scriptObj->mImportOptions = options;
+
+		return managedInstance;
+	}
+
 	void ScriptTextureImportOptions::internal_CreateInstance(MonoObject* instance)
 	{
 		ScriptTextureImportOptions* nativeInstance = new (bs_alloc<ScriptTextureImportOptions>()) ScriptTextureImportOptions(instance);
@@ -55,38 +93,38 @@ namespace BansheeEngine
 
 	PixelFormat ScriptTextureImportOptions::internal_GetPixelFormat(ScriptTextureImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getFormat();
+		return thisPtr->getTexImportOptions()->getFormat();
 	}
 
 	void ScriptTextureImportOptions::internal_SetPixelFormat(ScriptTextureImportOptions* thisPtr, PixelFormat value)
 	{
-		thisPtr->mImportOptions->setFormat(value);
+		thisPtr->getTexImportOptions()->setFormat(value);
 	}
 
 	bool ScriptTextureImportOptions::internal_GetGenerateMipmaps(ScriptTextureImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getGenerateMipmaps();
+		return thisPtr->getTexImportOptions()->getGenerateMipmaps();
 	}
 
 	void ScriptTextureImportOptions::internal_SetGenerateMipmaps(ScriptTextureImportOptions* thisPtr, bool value)
 	{
-		thisPtr->mImportOptions->setGenerateMipmaps(value);
+		thisPtr->getTexImportOptions()->setGenerateMipmaps(value);
 	}
 
 	UINT32 ScriptTextureImportOptions::internal_GetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getMaxMip();
+		return thisPtr->getTexImportOptions()->getMaxMip();
 	}
 
 	void ScriptTextureImportOptions::internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value)
 	{
-		thisPtr->mImportOptions->setMaxMip(value);
+		thisPtr->getTexImportOptions()->setMaxMip(value);
 	}
 
 	ScriptFontImportOptions::ScriptFontImportOptions(MonoObject* instance)
-		:ScriptObject(instance), mImportOptions(bs_shared_ptr<FontImportOptions>())
+		:ScriptObject(instance)
 	{
-
+		mImportOptions = bs_shared_ptr<FontImportOptions>();
 	}
 
 	void ScriptFontImportOptions::initRuntimeData()
@@ -102,11 +140,25 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_SetCharRanges", &ScriptFontImportOptions::internal_SetCharRanges);
 	}
 
+	SPtr<FontImportOptions> ScriptFontImportOptions::getFontImportOptions()
+	{
+		return std::static_pointer_cast<FontImportOptions>(mImportOptions);
+	}
+
 	MonoObject* ScriptFontImportOptions::create()
 	{
 		return metaData.scriptClass->createInstance();
 	}
 
+	MonoObject* ScriptFontImportOptions::create(const SPtr<FontImportOptions>& options)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		ScriptFontImportOptions* scriptObj = ScriptFontImportOptions::toNative(managedInstance);
+		scriptObj->mImportOptions = options;
+
+		return managedInstance;
+	}
+
 	void ScriptFontImportOptions::internal_CreateInstance(MonoObject* instance)
 	{
 		ScriptFontImportOptions* nativeInstance = new (bs_alloc<ScriptFontImportOptions>()) ScriptFontImportOptions(instance);
@@ -114,7 +166,7 @@ namespace BansheeEngine
 
 	MonoArray* ScriptFontImportOptions::internal_GetFontSizes(ScriptFontImportOptions* thisPtr)
 	{
-		Vector<UINT32> fontSizes = thisPtr->mImportOptions->getFontSizes();
+		Vector<UINT32> fontSizes = thisPtr->getFontImportOptions()->getFontSizes();
 
 		ScriptArray outArray = ScriptArray::create<UINT32>((UINT32)fontSizes.size());
 		for (UINT32 i = 0; i < fontSizes.size(); i++)
@@ -131,32 +183,32 @@ namespace BansheeEngine
 		for (UINT32 i = 0; i < inArray.size(); i++)
 			fontSizes[i] = inArray.get<UINT32>(i);
 
-		thisPtr->mImportOptions->setFontSizes(fontSizes);
+		thisPtr->getFontImportOptions()->setFontSizes(fontSizes);
 	}
 
 	UINT32 ScriptFontImportOptions::internal_GetDPI(ScriptFontImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getDPI();
+		return thisPtr->getFontImportOptions()->getDPI();
 	}
 
 	void ScriptFontImportOptions::internal_SetDPI(ScriptFontImportOptions* thisPtr, UINT32 value)
 	{
-		thisPtr->mImportOptions->setDPI(value);
+		thisPtr->getFontImportOptions()->setDPI(value);
 	}
 
 	bool ScriptFontImportOptions::internal_GetAntialiasing(ScriptFontImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getAntialiasing();
+		return thisPtr->getFontImportOptions()->getAntialiasing();
 	}
 
 	void ScriptFontImportOptions::internal_SetAntialiasing(ScriptFontImportOptions* thisPtr, bool value)
 	{
-		thisPtr->mImportOptions->setAntialiasing(value);
+		thisPtr->getFontImportOptions()->setAntialiasing(value);
 	}
 
 	MonoArray* ScriptFontImportOptions::internal_GetCharRanges(ScriptFontImportOptions* thisPtr)
 	{
-		Vector<std::pair<UINT32, UINT32>> charRanges = thisPtr->mImportOptions->getCharIndexRanges();
+		Vector<std::pair<UINT32, UINT32>> charRanges = thisPtr->getFontImportOptions()->getCharIndexRanges();
 
 		ScriptArray outArray = ScriptArray::create<ScriptCharRange>((UINT32)charRanges.size());
 		for (UINT32 i = 0; i < (UINT32)charRanges.size(); i++)
@@ -174,18 +226,18 @@ namespace BansheeEngine
 	{
 		ScriptArray inArray(value);
 
-		thisPtr->mImportOptions->clearCharIndexRanges();
+		thisPtr->getFontImportOptions()->clearCharIndexRanges();
 		for (UINT32 i = 0; i < inArray.size(); i++)
 		{
 			CharRange range = inArray.get<CharRange>(i);
-			thisPtr->mImportOptions->addCharIndexRange(range.start, range.end);
+			thisPtr->getFontImportOptions()->addCharIndexRange(range.start, range.end);
 		}
 	}
 
 	ScriptGpuProgramImportOptions::ScriptGpuProgramImportOptions(MonoObject* instance)
-		:ScriptObject(instance), mImportOptions(bs_shared_ptr<GpuProgramImportOptions>())
+		:ScriptObject(instance)
 	{
-
+		mImportOptions = bs_shared_ptr<GpuProgramImportOptions>();
 	}
 
 	void ScriptGpuProgramImportOptions::initRuntimeData()
@@ -201,11 +253,25 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_SetType", &ScriptGpuProgramImportOptions::internal_SetType);
 	}
 
+	SPtr<GpuProgramImportOptions> ScriptGpuProgramImportOptions::getGpuProgImportOptions()
+	{
+		return std::static_pointer_cast<GpuProgramImportOptions>(mImportOptions);
+	}
+
 	MonoObject* ScriptGpuProgramImportOptions::create()
 	{
 		return metaData.scriptClass->createInstance();
 	}
 
+	MonoObject* ScriptGpuProgramImportOptions::create(const SPtr<GpuProgramImportOptions>& options)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		ScriptGpuProgramImportOptions* scriptObj = ScriptGpuProgramImportOptions::toNative(managedInstance);
+		scriptObj->mImportOptions = options;
+
+		return managedInstance;
+	}
+
 	void ScriptGpuProgramImportOptions::internal_CreateInstance(MonoObject* instance)
 	{
 		ScriptGpuProgramImportOptions* nativeInstance = new (bs_alloc<ScriptGpuProgramImportOptions>()) ScriptGpuProgramImportOptions(instance);
@@ -213,41 +279,41 @@ namespace BansheeEngine
 
 	MonoString* ScriptGpuProgramImportOptions::internal_GetEntryPoint(ScriptGpuProgramImportOptions* thisPtr)
 	{
-		return MonoUtil::stringToMono(MonoManager::instance().getDomain(), thisPtr->mImportOptions->getEntryPoint());
+		return MonoUtil::stringToMono(MonoManager::instance().getDomain(), thisPtr->getGpuProgImportOptions()->getEntryPoint());
 	}
 
 	void ScriptGpuProgramImportOptions::internal_SetEntryPoint(ScriptGpuProgramImportOptions* thisPtr, MonoString* value)
 	{
-		thisPtr->mImportOptions->setEntryPoint(MonoUtil::monoToString(value));
+		thisPtr->getGpuProgImportOptions()->setEntryPoint(MonoUtil::monoToString(value));
 	}
 
 	GpuLanguage ScriptGpuProgramImportOptions::internal_GetLanguage(ScriptGpuProgramImportOptions* thisPtr)
 	{
-		return Renderer::getGpuLanguageType(thisPtr->mImportOptions->getLanguage());
+		return Renderer::getGpuLanguageType(thisPtr->getGpuProgImportOptions()->getLanguage());
 	}
 
 	void ScriptGpuProgramImportOptions::internal_SetLanguage(ScriptGpuProgramImportOptions* thisPtr, GpuLanguage value)
 	{
-		thisPtr->mImportOptions->setLanguage(Renderer::getGpuLanguageName(value));
+		thisPtr->getGpuProgImportOptions()->setLanguage(Renderer::getGpuLanguageName(value));
 	}
 
 	GpuProgramProfile ScriptGpuProgramImportOptions::internal_GetProfile(ScriptGpuProgramImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getProfile();
+		return thisPtr->getGpuProgImportOptions()->getProfile();
 	}
 
 	void ScriptGpuProgramImportOptions::internal_SetProfile(ScriptGpuProgramImportOptions* thisPtr, GpuProgramProfile value)
 	{
-		thisPtr->mImportOptions->setProfile(value);
+		thisPtr->getGpuProgImportOptions()->setProfile(value);
 	}
 
 	GpuProgramType ScriptGpuProgramImportOptions::internal_GetType(ScriptGpuProgramImportOptions* thisPtr)
 	{
-		return thisPtr->mImportOptions->getType();
+		return thisPtr->getGpuProgImportOptions()->getType();
 	}
 
 	void ScriptGpuProgramImportOptions::internal_SetType(ScriptGpuProgramImportOptions* thisPtr, GpuProgramType value)
 	{
-		thisPtr->mImportOptions->setType(value);
+		thisPtr->getGpuProgImportOptions()->setType(value);
 	}
 }

SBansheeEditor/Source/BsScriptProjectLibrary.cpp

@@ -2,9 +2,9 @@
 #include "BsScriptMeta.h"
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
+#include "BsMonoMethod.h"
 #include "BsMonoManager.h"
 #include "BsMonoUtil.h"
-#include "BsProjectLibrary.h"
 #include "BsScriptResource.h"
 #include "BsResources.h"
 #include "BsResource.h"
@@ -13,9 +13,15 @@
 #include "BsScriptTexture2D.h"
 #include "BsScriptSpriteTexture.h"
 #include "BsScriptFont.h"
+#include "BsScriptImportOptions.h"
+
+using namespace std::placeholders;
 
 namespace BansheeEngine
 {
+	HEvent ScriptProjectLibrary::mOnEntryAddedConn;
+	HEvent ScriptProjectLibrary::mOnEntryRemovedConn;
+
 	ScriptProjectLibrary::ScriptProjectLibrary(MonoObject* instance)
 		:ScriptObject(instance)
 	{ }
@@ -34,6 +40,9 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_Rename", &ScriptProjectLibrary::internal_Rename);
 		metaData.scriptClass->addInternalCall("Internal_Move", &ScriptProjectLibrary::internal_Move);
 		metaData.scriptClass->addInternalCall("Internal_Copy", &ScriptProjectLibrary::internal_Copy);
+
+		OnEntryAddedThunk = (OnEntryChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnEntryAdded", 1)->getThunk();
+		OnEntryRemovedThunk = (OnEntryChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnEntryRemoved", 1)->getThunk();
 	}
 
 	void ScriptProjectLibrary::internal_Create(MonoObject* resource, MonoString* path)
@@ -72,27 +81,58 @@ namespace BansheeEngine
 
 	void ScriptProjectLibrary::internal_Save(MonoObject* resource)
 	{
+		ScriptResource* srcResource = ScriptResource::toNative(resource);
 
+		if (srcResource != nullptr)
+			ProjectLibrary::instance().saveEntry(srcResource->getNativeHandle());
 	}
 
 	MonoObject* ScriptProjectLibrary::internal_GetRoot()
 	{
-		// TODO
+		return ScriptDirectoryEntry::create(static_cast<const ProjectLibrary::DirectoryEntry*>(ProjectLibrary::instance().getRootEntry()));
 	}
 
 	void ScriptProjectLibrary::internal_Reimport(MonoString* path, MonoObject* options, bool force)
 	{
-		// TODO
+		Path assetPath = MonoUtil::monoToWString(path);
+
+		SPtr<ImportOptions> nativeOptions;
+		if (options != nullptr)
+		{
+			ScriptImportOptions* scriptOptions = ScriptImportOptions::toNative(options);
+			nativeOptions = scriptOptions->getImportOptions();
+		}
+
+		ProjectLibrary::instance().reimport(assetPath, nativeOptions, force);
 	}
 
 	MonoObject* ScriptProjectLibrary::internal_GetEntry(MonoString* path)
 	{
-		// TODO
+		Path assetPath = MonoUtil::monoToWString(path);
+
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(assetPath);
+		if (entry == nullptr)
+			return nullptr;
+
+		if (entry->type == ProjectLibrary::LibraryEntryType::File)
+			return ScriptFileEntry::create(static_cast<ProjectLibrary::ResourceEntry*>(entry));
+		else
+			return ScriptDirectoryEntry::create(static_cast<ProjectLibrary::DirectoryEntry*>(entry));
 	}
 
 	MonoString* ScriptProjectLibrary::internal_GetPath(MonoObject* resource)
 	{
+		ScriptResource* srcResource = ScriptResource::toNative(resource);
+
+		if (srcResource != nullptr)
+		{
+			Path nativePath = ProjectLibrary::instance().uuidToPath(srcResource->getNativeHandle().getUUID());
+			nativePath.getRelative(ProjectLibrary::instance().getResourcesFolder());
 
+			return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), nativePath.toWString());
+		}
+
+		return nullptr;
 	}
 
 	void ScriptProjectLibrary::internal_Delete(MonoString* path)
@@ -130,4 +170,185 @@ namespace BansheeEngine
 
 		ProjectLibrary::instance().copyEntry(oldPathNative, newPathNative, overwrite);
 	}
+
+	void ScriptProjectLibrary::startUp()
+	{
+		mOnEntryAddedConn = ProjectLibrary::instance().onEntryAdded.connect(std::bind(&ScriptProjectLibrary::onEntryAdded, _1));
+		mOnEntryRemovedConn = ProjectLibrary::instance().onEntryRemoved.connect(std::bind(&ScriptProjectLibrary::onEntryRemoved, _1));
+	}
+
+	void ScriptProjectLibrary::shutDown()
+	{
+		mOnEntryAddedConn.disconnect();
+		mOnEntryRemovedConn.disconnect();
+	}
+
+	void ScriptProjectLibrary::onEntryAdded(const Path& path)
+	{
+		MonoString* pathStr = MonoUtil::wstringToMono(MonoManager::instance().getDomain(), path.toWString());
+
+		MonoException* exception = nullptr;
+		OnEntryAddedThunk(pathStr, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+
+	void ScriptProjectLibrary::onEntryRemoved(const Path& path)
+	{
+		MonoString* pathStr = MonoUtil::wstringToMono(MonoManager::instance().getDomain(), path.toWString());
+
+		MonoException* exception = nullptr;
+		OnEntryRemovedThunk(pathStr, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+
+	ScriptLibraryEntryBase::ScriptLibraryEntryBase(MonoObject* instance)
+		:ScriptObjectBase(instance)
+	{ }
+
+	void ScriptLibraryEntry::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_GetPath", &ScriptLibraryEntry::internal_GetPath);
+		metaData.scriptClass->addInternalCall("Internal_GetName", &ScriptLibraryEntry::internal_GetName);
+		metaData.scriptClass->addInternalCall("Internal_GetType", &ScriptLibraryEntry::internal_GetType);
+		metaData.scriptClass->addInternalCall("Internal_GetParent", &ScriptLibraryEntry::internal_GetParent);
+	}
+
+	MonoString* ScriptLibraryEntry::internal_GetPath(ScriptLibraryEntryBase* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr)
+			return nullptr;
+
+		return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), entry->path.toWString());
+	}
+
+	MonoString* ScriptLibraryEntry::internal_GetName(ScriptLibraryEntryBase* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr)
+			return nullptr;
+
+		return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), entry->elementName);
+	}
+
+	ProjectLibrary::LibraryEntryType ScriptLibraryEntry::internal_GetType(ScriptLibraryEntryBase* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr)
+			return ProjectLibrary::LibraryEntryType::File; // Note: We don't actually know what this entry is, because it doesn't exist anymore
+
+		return entry->type;
+	}
+
+	MonoObject* ScriptLibraryEntry::internal_GetParent(ScriptLibraryEntryBase* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr || entry->parent == nullptr)
+			return nullptr;
+
+		return ScriptDirectoryEntry::create(entry->parent);
+	}
+
+	ScriptDirectoryEntry::ScriptDirectoryEntry(MonoObject* instance, const Path& assetPath)
+		:ScriptObject(instance)
+	{
+		mAssetPath = assetPath;
+	}
+
+	MonoObject* ScriptDirectoryEntry::create(const ProjectLibrary::DirectoryEntry* entry)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		bs_new<ScriptDirectoryEntry>(managedInstance, entry->path);
+
+		return managedInstance;
+	}
+
+	void ScriptDirectoryEntry::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_GetChildren", &ScriptDirectoryEntry::internal_GetChildren);
+	}
+
+	MonoArray* ScriptDirectoryEntry::internal_GetChildren(ScriptDirectoryEntry* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr || entry->type != ProjectLibrary::LibraryEntryType::Directory)
+			return ScriptArray::create<ScriptLibraryEntry>(0).getInternal();
+
+		ProjectLibrary::DirectoryEntry* dirEntry = static_cast<ProjectLibrary::DirectoryEntry*>(entry);
+		ScriptArray outArray = ScriptArray::create<ScriptLibraryEntry>((UINT32)dirEntry->mChildren.size());
+		for (UINT32 i = 0; i < (UINT32)dirEntry->mChildren.size(); i++)
+		{
+			ProjectLibrary::LibraryEntry* childEntry = dirEntry->mChildren[i];
+			MonoObject* managedChildEntry = nullptr;
+
+			if (childEntry->type == ProjectLibrary::LibraryEntryType::File)
+				managedChildEntry = ScriptFileEntry::create(static_cast<ProjectLibrary::ResourceEntry*>(childEntry));
+			else
+				managedChildEntry = ScriptDirectoryEntry::create(static_cast<ProjectLibrary::DirectoryEntry*>(childEntry));
+
+			outArray.set(i, managedChildEntry);
+		}
+
+		return outArray.getInternal();
+	}
+
+	ScriptFileEntry::ScriptFileEntry(MonoObject* instance, const Path& assetPath)
+		:ScriptObject(instance)
+	{
+		mAssetPath = assetPath;
+	}
+
+	MonoObject* ScriptFileEntry::create(const ProjectLibrary::ResourceEntry* entry)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		bs_new<ScriptFileEntry>(managedInstance, entry->path);
+
+		return managedInstance;
+	}
+
+	void ScriptFileEntry::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_GetImportOptions", &ScriptFileEntry::internal_GetImportOptions);
+		metaData.scriptClass->addInternalCall("Internal_GetUUID", &ScriptFileEntry::internal_GetUUID);
+		metaData.scriptClass->addInternalCall("Internal_GetIcon", &ScriptFileEntry::internal_GetIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetResourceType", &ScriptFileEntry::internal_GetResourceType);
+	}
+
+	MonoObject* ScriptFileEntry::internal_GetImportOptions(ScriptFileEntry* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr || entry->type != ProjectLibrary::LibraryEntryType::File)
+			return nullptr;
+
+		ProjectLibrary::ResourceEntry* fileEntry = static_cast<ProjectLibrary::ResourceEntry*>(entry);
+		return ScriptImportOptions::create(fileEntry->meta->getImportOptions());
+	}
+
+	MonoString* ScriptFileEntry::internal_GetUUID(ScriptFileEntry* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr || entry->type != ProjectLibrary::LibraryEntryType::File)
+			return nullptr;
+
+		ProjectLibrary::ResourceEntry* fileEntry = static_cast<ProjectLibrary::ResourceEntry*>(entry);
+		return MonoUtil::stringToMono(MonoManager::instance().getDomain(), fileEntry->meta->getUUID());
+	}
+
+	MonoObject* ScriptFileEntry::internal_GetIcon(ScriptFileEntry* thisPtr)
+	{
+		// TODO - Icons not supported yet
+		return nullptr;
+	}
+
+	ScriptResourceType ScriptFileEntry::internal_GetResourceType(ScriptFileEntry* thisPtr)
+	{
+		ProjectLibrary::LibraryEntry* entry = ProjectLibrary::instance().findEntry(thisPtr->getAssetPath());
+		if (entry == nullptr || entry->type != ProjectLibrary::LibraryEntryType::File)
+			return ScriptResourceType::Undefined;
+
+		ProjectLibrary::ResourceEntry* fileEntry = static_cast<ProjectLibrary::ResourceEntry*>(entry);
+		return ScriptResource::getTypeFromTypeId(fileEntry->meta->getTypeID());
+	}
 }

SBansheeEngine/Include/BsScriptResource.h

@@ -5,6 +5,11 @@
 
 namespace BansheeEngine
 {
+	enum class ScriptResourceType
+	{
+		Texture, SpriteTexture, Mesh, Font, GpuProgram, Undefined
+	};
+
 	class BS_SCR_BE_EXPORT ScriptResourceBase : public PersistentScriptObjectBase
 	{
 	public:
@@ -31,6 +36,8 @@ namespace BansheeEngine
 		static String getTypeName() { return "Resource"; }
 		static void initRuntimeData() { }
 
+		static ScriptResourceType getTypeFromTypeId(UINT32 typeId);
+
 	private:
 		ScriptResource(MonoObject* instance)
 			:ScriptObject(instance)

SBansheeEngine/Source/BsScriptResource.cpp

@@ -19,4 +19,23 @@ namespace BansheeEngine
 
 		PersistentScriptObjectBase::endRefresh(backupData);
 	}
+
+	ScriptResourceType ScriptResource::getTypeFromTypeId(UINT32 typeId)
+	{
+		switch (typeId)
+		{
+		case TID_Texture:
+			return ScriptResourceType::Texture;
+		case TID_SpriteTexture:
+			return ScriptResourceType::SpriteTexture;
+		case TID_Mesh:
+			return ScriptResourceType::Mesh;
+		case TID_GpuProgram:
+			return ScriptResourceType::GpuProgram;
+		case TID_Font:
+			return ScriptResourceType::Font;
+		}
+
+		return ScriptResourceType::Undefined;
+	}
 }