WIP C# interface for ImportOptions complete

BansheeCore/Include/BsCorePrerequisites.h

@@ -123,6 +123,9 @@ namespace BansheeEngine
 	class CoreObject;
 	class CoreObjectCore;
 	class ImportOptions;
+	class TextureImportOptions;
+	class FontImportOptions;
+	class GpuProgramImportOptions;
 	struct FontData;
 	class GameObject;
 	class GpuResourceData;

BansheeEngine/Include/BsEnums.h

@@ -38,4 +38,12 @@ namespace BansheeEngine
 	{
 		LayoutX, LayoutY, LayoutExplicit
 	};
+
+	/**
+	 * @brief	Languages used for writing GPU programs.
+	 */
+	enum class GpuLanguage
+	{
+		HLSL, GLSL, Undefined
+	};
 }

BansheeEngine/Include/BsRenderer.h

@@ -36,6 +36,16 @@ namespace BansheeEngine
 		 *			Internal method.
 		 */
 		virtual void _notifyRenderableRemoved(RenderableHandlerCore* renderable) { }
+
+		/**
+		 * @brief	Returns a GPU language type based on its name.
+		 */
+		static GpuLanguage getGpuLanguageType(const String& name);
+
+		/**
+		 * @brief	Returns a GPU language name based on its type.
+		 */
+		static String getGpuLanguageName(GpuLanguage language);
 	};
 
 	/**

BansheeEngine/Source/BsRenderer.cpp

@@ -3,6 +3,29 @@
 
 namespace BansheeEngine
 {
+	GpuLanguage Renderer::getGpuLanguageType(const String& name)
+	{
+		if (name == "hlsl")
+			return GpuLanguage::HLSL;
+		else if (name == "glsl")
+			return GpuLanguage::GLSL;
+
+		return GpuLanguage::Undefined;
+	}
+
+	String Renderer::getGpuLanguageName(GpuLanguage language)
+	{
+		switch (language)
+		{
+		case GpuLanguage::HLSL:
+			return "hlsl";
+		case GpuLanguage::GLSL:
+			return "glsl";
+		}
+
+		return "";
+	}
+
 	SPtr<Renderer> gRenderer()
 	{
 		return std::static_pointer_cast<Renderer>(RendererManager::instance().getActive());

BansheeMono/Include/BsMonoArray.h

@@ -11,6 +11,7 @@ namespace BansheeEngine
 	public:
 		ScriptArray(MonoArray* existingArray);
 		ScriptArray(MonoClass& klass, UINT32 size);
+		ScriptArray(::MonoClass* klass, UINT32 size);
 
 		template<class T>
 		T get(UINT32 idx)
@@ -30,13 +31,41 @@ namespace BansheeEngine
 			return ScriptArray(*T::getMetaData()->scriptClass, size);
 		}
 
+		template<>
+		static ScriptArray create<UINT32>(UINT32 size)
+		{
+			return ScriptArray(mono_get_uint32_class(), size);
+		}
+
+		template<>
+		static ScriptArray create<INT32>(UINT32 size)
+		{
+			return ScriptArray(mono_get_int32_class(), size);
+		}
+
+		template<>
+		static ScriptArray create<WString>(UINT32 size)
+		{
+			return ScriptArray(mono_get_string_class(), size);
+		}
+
+		template<>
+		static ScriptArray create<String>(UINT32 size)
+		{
+			return ScriptArray(mono_get_string_class(), size);
+		}
+
+		template<>
+		static ScriptArray create<float>(UINT32 size)
+		{
+			return ScriptArray(mono_get_single_class(), size);
+		}
+
 		UINT32 size() const;
 
 		MonoArray* getInternal() const { return mInternal; }
 
 	private:
-		MonoArray* createArray(MonoClass& klass, UINT32 size);
-
 		MonoArray* mInternal;
 	};
 }

BansheeMono/Source/BsMonoArray.cpp

@@ -13,17 +13,17 @@ namespace BansheeEngine
 	ScriptArray::ScriptArray(MonoClass& klass, UINT32 size)
 		: mInternal(nullptr)
 	{
-		mInternal = createArray(klass, size);
+		mInternal = mono_array_new(MonoManager::instance().getDomain(), klass._getInternalClass(), size);
 	}
 
-	UINT32 ScriptArray::size() const
+	ScriptArray::ScriptArray(::MonoClass* klass, UINT32 size)
+		: mInternal(nullptr)
 	{
-		return (UINT32)mono_array_length(mInternal);
+		mInternal = mono_array_new(MonoManager::instance().getDomain(), klass, size);
 	}
 
-	MonoArray* ScriptArray::createArray(MonoClass& klass, UINT32 size)
+	UINT32 ScriptArray::size() const
 	{
-		return mono_array_new(MonoManager::instance().getDomain(),
-			klass._getInternalClass(), size);
+		return (UINT32)mono_array_length(mInternal);
 	}
 }

MBansheeEngine/GpuProgram.cs

@@ -5,11 +5,12 @@
         // TODO - Dummy class
     }
 
+    // Note: Must be equal to C++ enum GpuLanguage
     public enum GpuLanguage
     {
-        HLSL9,
-        HLSL11,
-        GLSL
+        HLSL,
+        GLSL,
+        Undefined
     }
 
     // Note: Must be equal to C++ enum GpuProgramType

SBansheeEditor/Include/BsScriptImportOptions.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsPixelData.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptTextureImportOptions : public ScriptObject<ScriptTextureImportOptions>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "TextureImportOptions")
+
+		static MonoObject* create();
+
+	private:
+		static void internal_CreateInstance(MonoObject* instance);
+		static PixelFormat internal_GetPixelFormat(ScriptTextureImportOptions* thisPtr);
+		static void internal_SetPixelFormat(ScriptTextureImportOptions* thisPtr, PixelFormat value);
+		static bool internal_GetGenerateMipmaps(ScriptTextureImportOptions* thisPtr);
+		static void internal_SetGenerateMipmaps(ScriptTextureImportOptions* thisPtr, bool value);
+		static UINT32 internal_GetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr);
+		static void internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value);
+
+		ScriptTextureImportOptions(MonoObject* instance);
+
+		SPtr<TextureImportOptions> mImportOptions;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptFontImportOptions : public ScriptObject <ScriptFontImportOptions>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "FontImportOptions")
+
+		static MonoObject* create();
+
+	private:
+		static void internal_CreateInstance(MonoObject* instance);
+		static MonoArray* internal_GetFontSizes(ScriptFontImportOptions* thisPtr);
+		static void internal_SetFontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value);
+		static UINT32 internal_GetDPI(ScriptFontImportOptions* thisPtr);
+		static void internal_SetDPI(ScriptFontImportOptions* thisPtr, UINT32 value);
+		static bool internal_GetAntialiasing(ScriptFontImportOptions* thisPtr);
+		static void internal_SetAntialiasing(ScriptFontImportOptions* thisPtr, bool value);
+		static MonoArray* internal_GetCharRanges(ScriptFontImportOptions* thisPtr);
+		static void internal_SetCharRanges(ScriptFontImportOptions* thisPtr, MonoArray* value);
+
+		ScriptFontImportOptions(MonoObject* instance);
+
+		SPtr<FontImportOptions> mImportOptions;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptGpuProgramImportOptions : public ScriptObject <ScriptGpuProgramImportOptions>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GpuProgramImportOptions")
+
+		static MonoObject* create();
+
+	private:
+		static void internal_CreateInstance(MonoObject* instance);
+		static MonoString* internal_GetEntryPoint(ScriptGpuProgramImportOptions* thisPtr);
+		static void internal_SetEntryPoint(ScriptGpuProgramImportOptions* thisPtr, MonoString* value);
+		static GpuLanguage internal_GetLanguage(ScriptGpuProgramImportOptions* thisPtr);
+		static void internal_SetLanguage(ScriptGpuProgramImportOptions* thisPtr, GpuLanguage value);
+		static GpuProgramProfile internal_GetProfile(ScriptGpuProgramImportOptions* thisPtr);
+		static void internal_SetProfile(ScriptGpuProgramImportOptions* thisPtr, GpuProgramProfile value);
+		static GpuProgramType internal_GetType(ScriptGpuProgramImportOptions* thisPtr);
+		static void internal_SetType(ScriptGpuProgramImportOptions* thisPtr, GpuProgramType value);
+
+		ScriptGpuProgramImportOptions(MonoObject* instance);
+
+		SPtr<GpuProgramImportOptions> mImportOptions;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptCharRange : public ScriptObject <ScriptCharRange>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "Color")
+
+		static Color unbox(MonoObject* obj);
+		static MonoObject* box(const Color& value);
+
+	private:
+		ScriptCharRange(MonoObject* instance);
+	};
+}

SBansheeEditor/SBansheeEditor.vcxproj

@@ -264,6 +264,7 @@
     <ClInclude Include="Include\BsScriptHandleSliderLine.h" />
     <ClInclude Include="Include\BsScriptHandleSliderManager.h" />
     <ClInclude Include="Include\BsScriptHandleSliderPlane.h" />
+    <ClInclude Include="Include\BsScriptImportOptions.h" />
     <ClInclude Include="Include\BsScriptModalWindow.h" />
     <ClInclude Include="Include\BsScriptProjectLibrary.h" />
     <ClInclude Include="Include\BsScriptSceneViewHandler.h" />
@@ -302,6 +303,7 @@
     <ClCompile Include="Source\BsScriptHandleSliderLine.cpp" />
     <ClCompile Include="Source\BsScriptHandleSliderManager.cpp" />
     <ClCompile Include="Source\BsScriptHandleSliderPlane.cpp" />
+    <ClCompile Include="Source\BsScriptImportOptions.cpp" />
     <ClCompile Include="Source\BsScriptModalWindow.cpp" />
     <ClCompile Include="Source\BsScriptProjectLibrary.cpp" />
     <ClCompile Include="Source\BsScriptSceneViewHandler.cpp" />

SBansheeEditor/SBansheeEditor.vcxproj.filters

@@ -123,6 +123,9 @@
     <ClInclude Include="Include\BsScriptDragDropManager.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptImportOptions.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptEditorPlugin.cpp">
@@ -233,5 +236,8 @@
     <ClCompile Include="Source\BsScriptDragDropManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptImportOptions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEditor/Source/BsScriptImportOptions.cpp

@@ -0,0 +1,253 @@
+#include "BsScriptImportOptions.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsMonoUtil.h"
+#include "BsTextureImportOptions.h"
+#include "BsFontImportOptions.h"
+#include "BsGpuProgramImportOptions.h"
+#include "BsRenderer.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	struct CharRange
+	{
+		UINT32 start, end;
+	};
+
+	ScriptCharRange::ScriptCharRange(MonoObject* instance)
+		:ScriptObject(instance)
+	{ }
+
+	void ScriptCharRange::initRuntimeData()
+	{ }
+
+	ScriptTextureImportOptions::ScriptTextureImportOptions(MonoObject* instance)
+		:ScriptObject(instance), mImportOptions(bs_shared_ptr<TextureImportOptions>())
+	{
+
+	}
+
+	void ScriptTextureImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptTextureImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetPixelFormat", &ScriptTextureImportOptions::internal_GetPixelFormat);
+		metaData.scriptClass->addInternalCall("Internal_SetPixelFormat", &ScriptTextureImportOptions::internal_SetPixelFormat);
+		metaData.scriptClass->addInternalCall("Internal_GetGenerateMipmaps", &ScriptTextureImportOptions::internal_GetGenerateMipmaps);
+		metaData.scriptClass->addInternalCall("Internal_SetGenerateMipmaps", &ScriptTextureImportOptions::internal_SetGenerateMipmaps);
+		metaData.scriptClass->addInternalCall("Internal_GetMaxMipmapLevel", &ScriptTextureImportOptions::internal_GetMaxMipmapLevel);
+		metaData.scriptClass->addInternalCall("Internal_SetMaxMipmapLevel", &ScriptTextureImportOptions::internal_SetMaxMipmapLevel);
+	}
+
+	MonoObject* ScriptTextureImportOptions::create()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+
+	void ScriptTextureImportOptions::internal_CreateInstance(MonoObject* instance)
+	{
+		ScriptTextureImportOptions* nativeInstance = new (bs_alloc<ScriptTextureImportOptions>()) ScriptTextureImportOptions(instance);
+	}
+
+	PixelFormat ScriptTextureImportOptions::internal_GetPixelFormat(ScriptTextureImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getFormat();
+	}
+
+	void ScriptTextureImportOptions::internal_SetPixelFormat(ScriptTextureImportOptions* thisPtr, PixelFormat value)
+	{
+		thisPtr->mImportOptions->setFormat(value);
+	}
+
+	bool ScriptTextureImportOptions::internal_GetGenerateMipmaps(ScriptTextureImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getGenerateMipmaps();
+	}
+
+	void ScriptTextureImportOptions::internal_SetGenerateMipmaps(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->mImportOptions->setGenerateMipmaps(value);
+	}
+
+	UINT32 ScriptTextureImportOptions::internal_GetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getMaxMip();
+	}
+
+	void ScriptTextureImportOptions::internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value)
+	{
+		thisPtr->mImportOptions->setMaxMip(value);
+	}
+
+	ScriptFontImportOptions::ScriptFontImportOptions(MonoObject* instance)
+		:ScriptObject(instance), mImportOptions(bs_shared_ptr<FontImportOptions>())
+	{
+
+	}
+
+	void ScriptFontImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptFontImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetFontSizes", &ScriptFontImportOptions::internal_GetFontSizes);
+		metaData.scriptClass->addInternalCall("Internal_SetFontSizes", &ScriptFontImportOptions::internal_SetFontSizes);
+		metaData.scriptClass->addInternalCall("Internal_GetDPI", &ScriptFontImportOptions::internal_GetDPI);
+		metaData.scriptClass->addInternalCall("Internal_SetDPI", &ScriptFontImportOptions::internal_SetDPI);
+		metaData.scriptClass->addInternalCall("Internal_GetAntialiasing", &ScriptFontImportOptions::internal_GetAntialiasing);
+		metaData.scriptClass->addInternalCall("Internal_SetAntialiasing", &ScriptFontImportOptions::internal_SetAntialiasing);
+		metaData.scriptClass->addInternalCall("Internal_GetCharRanges", &ScriptFontImportOptions::internal_GetCharRanges);
+		metaData.scriptClass->addInternalCall("Internal_SetCharRanges", &ScriptFontImportOptions::internal_SetCharRanges);
+	}
+
+	MonoObject* ScriptFontImportOptions::create()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+
+	void ScriptFontImportOptions::internal_CreateInstance(MonoObject* instance)
+	{
+		ScriptFontImportOptions* nativeInstance = new (bs_alloc<ScriptFontImportOptions>()) ScriptFontImportOptions(instance);
+	}
+
+	MonoArray* ScriptFontImportOptions::internal_GetFontSizes(ScriptFontImportOptions* thisPtr)
+	{
+		Vector<UINT32> fontSizes = thisPtr->mImportOptions->getFontSizes();
+
+		ScriptArray outArray = ScriptArray::create<UINT32>((UINT32)fontSizes.size());
+		for (UINT32 i = 0; i < fontSizes.size(); i++)
+			outArray.set(i, fontSizes[i]);
+
+		return outArray.getInternal();
+	}
+
+	void ScriptFontImportOptions::internal_SetFontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value)
+	{
+		ScriptArray inArray(value);
+
+		Vector<UINT32> fontSizes(inArray.size());
+		for (UINT32 i = 0; i < inArray.size(); i++)
+			fontSizes[i] = inArray.get<UINT32>(i);
+
+		thisPtr->mImportOptions->setFontSizes(fontSizes);
+	}
+
+	UINT32 ScriptFontImportOptions::internal_GetDPI(ScriptFontImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getDPI();
+	}
+
+	void ScriptFontImportOptions::internal_SetDPI(ScriptFontImportOptions* thisPtr, UINT32 value)
+	{
+		thisPtr->mImportOptions->setDPI(value);
+	}
+
+	bool ScriptFontImportOptions::internal_GetAntialiasing(ScriptFontImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getAntialiasing();
+	}
+
+	void ScriptFontImportOptions::internal_SetAntialiasing(ScriptFontImportOptions* thisPtr, bool value)
+	{
+		thisPtr->mImportOptions->setAntialiasing(value);
+	}
+
+	MonoArray* ScriptFontImportOptions::internal_GetCharRanges(ScriptFontImportOptions* thisPtr)
+	{
+		Vector<std::pair<UINT32, UINT32>> charRanges = thisPtr->mImportOptions->getCharIndexRanges();
+
+		ScriptArray outArray = ScriptArray::create<ScriptCharRange>((UINT32)charRanges.size());
+		for (UINT32 i = 0; i < (UINT32)charRanges.size(); i++)
+		{
+			CharRange range;
+			range.start = charRanges[i].first;
+			range.end = charRanges[i].second;
+			outArray.set(i, range);
+		}
+
+		return outArray.getInternal();
+	}
+
+	void ScriptFontImportOptions::internal_SetCharRanges(ScriptFontImportOptions* thisPtr, MonoArray* value)
+	{
+		ScriptArray inArray(value);
+
+		thisPtr->mImportOptions->clearCharIndexRanges();
+		for (UINT32 i = 0; i < inArray.size(); i++)
+		{
+			CharRange range = inArray.get<CharRange>(i);
+			thisPtr->mImportOptions->addCharIndexRange(range.start, range.end);
+		}
+	}
+
+	ScriptGpuProgramImportOptions::ScriptGpuProgramImportOptions(MonoObject* instance)
+		:ScriptObject(instance), mImportOptions(bs_shared_ptr<GpuProgramImportOptions>())
+	{
+
+	}
+
+	void ScriptGpuProgramImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGpuProgramImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetEntryPoint", &ScriptGpuProgramImportOptions::internal_GetEntryPoint);
+		metaData.scriptClass->addInternalCall("Internal_SetEntryPoint", &ScriptGpuProgramImportOptions::internal_SetEntryPoint);
+		metaData.scriptClass->addInternalCall("Internal_GetLanguage", &ScriptGpuProgramImportOptions::internal_GetLanguage);
+		metaData.scriptClass->addInternalCall("Internal_SetLanguage", &ScriptGpuProgramImportOptions::internal_SetLanguage);
+		metaData.scriptClass->addInternalCall("Internal_GetProfile", &ScriptGpuProgramImportOptions::internal_GetProfile);
+		metaData.scriptClass->addInternalCall("Internal_SetProfile", &ScriptGpuProgramImportOptions::internal_SetProfile);
+		metaData.scriptClass->addInternalCall("Internal_GetType", &ScriptGpuProgramImportOptions::internal_GetType);
+		metaData.scriptClass->addInternalCall("Internal_SetType", &ScriptGpuProgramImportOptions::internal_SetType);
+	}
+
+	MonoObject* ScriptGpuProgramImportOptions::create()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+
+	void ScriptGpuProgramImportOptions::internal_CreateInstance(MonoObject* instance)
+	{
+		ScriptGpuProgramImportOptions* nativeInstance = new (bs_alloc<ScriptGpuProgramImportOptions>()) ScriptGpuProgramImportOptions(instance);
+	}
+
+	MonoString* ScriptGpuProgramImportOptions::internal_GetEntryPoint(ScriptGpuProgramImportOptions* thisPtr)
+	{
+		return MonoUtil::stringToMono(MonoManager::instance().getDomain(), thisPtr->mImportOptions->getEntryPoint());
+	}
+
+	void ScriptGpuProgramImportOptions::internal_SetEntryPoint(ScriptGpuProgramImportOptions* thisPtr, MonoString* value)
+	{
+		thisPtr->mImportOptions->setEntryPoint(MonoUtil::monoToString(value));
+	}
+
+	GpuLanguage ScriptGpuProgramImportOptions::internal_GetLanguage(ScriptGpuProgramImportOptions* thisPtr)
+	{
+		return Renderer::getGpuLanguageType(thisPtr->mImportOptions->getLanguage());
+	}
+
+	void ScriptGpuProgramImportOptions::internal_SetLanguage(ScriptGpuProgramImportOptions* thisPtr, GpuLanguage value)
+	{
+		thisPtr->mImportOptions->setLanguage(Renderer::getGpuLanguageName(value));
+	}
+
+	GpuProgramProfile ScriptGpuProgramImportOptions::internal_GetProfile(ScriptGpuProgramImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getProfile();
+	}
+
+	void ScriptGpuProgramImportOptions::internal_SetProfile(ScriptGpuProgramImportOptions* thisPtr, GpuProgramProfile value)
+	{
+		thisPtr->mImportOptions->setProfile(value);
+	}
+
+	GpuProgramType ScriptGpuProgramImportOptions::internal_GetType(ScriptGpuProgramImportOptions* thisPtr)
+	{
+		return thisPtr->mImportOptions->getType();
+	}
+
+	void ScriptGpuProgramImportOptions::internal_SetType(ScriptGpuProgramImportOptions* thisPtr, GpuProgramType value)
+	{
+		thisPtr->mImportOptions->setType(value);
+	}
+}