Added C# MeshImportOptions and extended TextureImportOptions with new properties

BansheeCore/Include/BsCorePrerequisites.h

@@ -131,6 +131,7 @@ namespace BansheeEngine
 	class TextureImportOptions;
 	class FontImportOptions;
 	class GpuProgramImportOptions;
+	class MeshImportOptions;
 	struct FontBitmap;
 	class GameObject;
 	class GpuResourceData;

BansheeCore/Include/BsMeshImportOptions.h

@@ -37,7 +37,7 @@ namespace BansheeEngine
 		bool getImportNormals() const { return mImportNormals; }
 
 		/**
-		 * @brief	Sets a value that controls should mesh tangent/bitangent be imported
+		 * @brief	Sets a value that controls should mesh tangents/bitangents be imported
 		 *			if available.
 		 */
 		void setImportTangents(bool import) { mImportTangents = import; }

BansheeCore/Include/BsTextureImportOptions.h

@@ -32,13 +32,13 @@ namespace BansheeEngine
 		void setMaxMip(UINT32 maxMip) { mMaxMip = maxMip; }
 
 		/**
-		 * @brief	Sets whether the texture data is also stored in CPU memory.
+		 * @brief	Sets whether the texture data is also stored in main memory, available for fast CPU access.
 		 */
 		void setCPUReadable(bool readable) { mCPUReadable = readable; }
 
 		/**
 		 * @brief	Sets whether the texture data should be treated as if its in sRGB (gamma) space.
-		 *			Such texture will be converted by hardware to linear space before use.
+		 *			Such texture will be converted by hardware to linear space before use on the GPU.
 		 */
 		void setSRGB(bool sRGB) { mSRGB = sRGB; }
 
@@ -59,13 +59,13 @@ namespace BansheeEngine
 		UINT32 getMaxMip() const { return mMaxMip; }
 
 		/**
-		 * @brief	Retrieves whether the texture data is also stored in CPU memory.
+		 * @brief	Retrieves whether the texture data is also stored in main memory, available for fast CPU access.
 		 */
 		bool getCPUReadable() const { return mCPUReadable; }
 
 		/**
 		 * @brief	Retrieves whether the texture data should be treated as if its in sRGB (gamma) space.
-		 *			Such texture will be converted by hardware to linear space before use.
+		 *			Such texture will be converted by hardware to linear space before use on the GPU.
 		 */
 		bool getSRGB() const { return mSRGB; }
 

MBansheeEditor/ImportOptions.cs

@@ -5,7 +5,7 @@ using BansheeEngine;
 namespace BansheeEditor
 {
     /// <summary>
-    /// Base class for all import options. Import options allow control over how is a specific resource type imported.
+    /// Base class for all import options. Allows control over how is a specific resource type imported.
     /// </summary>
     public class ImportOptions : ScriptObject
     {
@@ -13,7 +13,7 @@ namespace BansheeEditor
     }
 
     /// <summary>
-    /// Import options that provide various options for controlling how is a texture file imported.
+    /// Provides options for controlling how is a texture resource imported.
     /// </summary>
     public class TextureImportOptions : ImportOptions
     {
@@ -46,12 +46,31 @@ namespace BansheeEditor
         /// <summary>
         /// Maximum mipmap level to generate, if mipmap generation is enabled.
         /// </summary>
-        public UInt32 MaxMipmapLevel
+        public int MaxMipmapLevel
         {
             get { return Internal_GetMaxMipmapLevel(mCachedPtr); }
             set { Internal_SetMaxMipmapLevel(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Determines whether the texture data is also stored in main memory, available for fast CPU access.
+        /// </summary>
+        public bool CPUReadable
+        {
+            get { return Internal_GetCPUReadable(mCachedPtr); }
+            set { Internal_SetCPUReadable(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Determines should the texture data be treated as if its in sRGB (gamma) space. Such texture will be converted by
+        /// hardware to linear space before use on the GPU.
+        /// </summary>
+        public bool IsSRGB
+        {
+            get { return Internal_GetIsSRGB(mCachedPtr); }
+            set { Internal_SetIsSRGB(mCachedPtr, value); }
+        }
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_CreateInstance(TextureImportOptions instance);
 
@@ -68,14 +87,148 @@ namespace BansheeEditor
         private static extern void Internal_SetGenerateMipmaps(IntPtr thisPtr, bool value);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern UInt32 Internal_GetMaxMipmapLevel(IntPtr thisPtr);
+        private static extern int Internal_GetMaxMipmapLevel(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetMaxMipmapLevel(IntPtr thisPtr, int value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetCPUReadable(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetCPUReadable(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetIsSRGB(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetIsSRGB(IntPtr thisPtr, bool value);
+    }
+
+    /// <summary>
+    /// Provides options for controlling how is a mesh resource imported.
+    /// </summary>
+    public class MeshImportOptions : ImportOptions
+    {
+        /// <summary>
+        /// Creates new mesh import options with default values.
+        /// </summary>
+        public MeshImportOptions()
+        {
+            Internal_CreateInstance(this);
+        }
+
+        /// <summary>
+        /// Determines whether the mesh data is also stored in main memory, available for fast CPU access. 
+        /// </summary>
+        public bool CPUReadable
+        {
+            get { return Internal_GetCPUReadable(mCachedPtr); }
+            set { Internal_SetCPUReadable(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Controls should mesh normals be imported if available.
+        /// </summary>
+        public bool ImportNormals
+        {
+            get { return Internal_GetImportNormals(mCachedPtr); }
+            set { Internal_SetImportNormals(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Controls should mesh tangents/bitangents be imported if available.
+        /// </summary>
+        public bool ImportTangents
+        {
+            get { return Internal_GetImportTangents(mCachedPtr); }
+            set { Internal_SetImportTangents(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Controls should mesh skin data like bone weights, indices and bind poses be imported if available.
+        /// </summary>
+        public bool ImportSkin
+        {
+            get { return Internal_GetImportSkin(mCachedPtr); }
+            set { Internal_SetImportSkin(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Controls should animation clips be imported if available.
+        /// </summary>
+        public bool ImportAnimation
+        {
+            get { return Internal_GetImportAnimation(mCachedPtr); }
+            set { Internal_SetImportAnimation(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Controls should mesh blend shapes be imported if available.
+        /// </summary>
+        public bool ImportBlendShapes
+        {
+            get { return Internal_GetImportBlendShapes(mCachedPtr); }
+            set { Internal_SetImportBlendShapes(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Uniformly scales the imported mesh by the specified value.
+        /// </summary>
+        public float Scale
+        {
+            get { return Internal_GetScale(mCachedPtr); }
+            set { Internal_SetScale(mCachedPtr, value); }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(MeshImportOptions instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetCPUReadable(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetCPUReadable(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetImportNormals(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetImportNormals(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetImportTangents(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetImportTangents(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetImportSkin(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetImportSkin(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetImportAnimation(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetImportAnimation(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetImportBlendShapes(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetImportBlendShapes(IntPtr thisPtr, bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetScale(IntPtr thisPtr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetMaxMipmapLevel(IntPtr thisPtr, UInt32 value);
+        private static extern void Internal_SetScale(IntPtr thisPtr, float value);
     }
 
     /// <summary>
-    /// Import options that provide various options for controlling how is a font file imported.
+    /// Import options that provide various options for controlling how is a font resource imported.
     /// </summary>
     public class FontImportOptions : ImportOptions
     {
@@ -152,7 +305,7 @@ namespace BansheeEditor
     }
 
     /// <summary>
-    /// Import options that provide various options for controlling how is a script file imported.
+    /// Provides various options for controlling how is a script file imported.
     /// </summary>
     public class ScriptCodeImportOptions : ImportOptions
     {

MBansheeEditor/Selection.cs

@@ -16,12 +16,6 @@ namespace BansheeEditor
         /// </summary>
         public static Action<SceneObject[], string[]> OnSelectionChanged;
 
-        /// <summary>
-        /// Triggered when a scene object ping is requested. Ping usually means the object will be highlighted in its 
-        /// respective editors.
-        /// </summary>
-        internal static Action<SceneObject> OnSceneObjectPing;
-
         /// <summary>
         /// Triggered when a resource ping is requested. Ping usually means the object will be highlighted in its respective
         /// editors.
@@ -137,8 +131,7 @@ namespace BansheeEditor
         /// <param name="so">Scene object to highlight.</param>
         private static void Internal_TriggerSceneObjectPing(SceneObject so)
         {
-            if (OnSceneObjectPing != null)
-                OnSceneObjectPing(so);
+            // Ignoring this until something needs this event
         }
 
         /// <summary>

SBansheeEditor/Include/BsScriptImportOptions.h

@@ -82,6 +82,58 @@ namespace BansheeEngine
 		static void internal_SetGenerateMipmaps(ScriptTextureImportOptions* thisPtr, bool value);
 		static UINT32 internal_GetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr);
 		static void internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value);
+		static bool internal_GetCPUReadable(ScriptTextureImportOptions* thisPtr);
+		static void internal_SetCPUReadable(ScriptTextureImportOptions* thisPtr, bool value);
+		static bool internal_GetIsSRGB(ScriptTextureImportOptions* thisPtr);
+		static void internal_SetIsSRGB(ScriptTextureImportOptions* thisPtr, bool value);
+	};
+
+	/**
+	* @brief	Interop class between C++ & CLR for MeshImportOptions.
+	*/
+	class BS_SCR_BED_EXPORT ScriptMeshImportOptions : public ScriptObject<ScriptMeshImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "MeshImportOptions")
+
+		/**
+		 * @brief	Creates a new managed MeshImportOptions instance containing the
+		 *			default import options for textures.
+		 */
+		static MonoObject* create();
+
+		/**
+		 * @brief	Creates a new managed MeshImportOptions instance containing
+		 *			the provided import options.
+		 */
+		static MonoObject* create(const SPtr<MeshImportOptions>& options);
+
+	private:
+		ScriptMeshImportOptions(MonoObject* instance);
+
+		/**
+		* @brief	Returns the internal native import options.
+		*/
+		SPtr<MeshImportOptions> getMeshImportOptions();
+
+		/************************************************************************/
+		/* 								CLR HOOKS						   		*/
+		/************************************************************************/
+		static void internal_CreateInstance(MonoObject* instance);
+		static bool internal_GetCPUReadable(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetCPUReadable(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool internal_GetImportNormals(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetImportNormals(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool internal_GetImportTangents(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetImportTangents(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool internal_GetImportSkin(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetImportSkin(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool internal_GetImportAnimation(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetImportAnimation(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool internal_GetImportBlendShapes(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetImportBlendShapes(ScriptMeshImportOptions* thisPtr, bool value);
+		static float internal_GetScale(ScriptMeshImportOptions* thisPtr);
+		static void internal_SetScale(ScriptMeshImportOptions* thisPtr, float value);
 	};
 
 	/**

SBansheeEditor/Source/BsScriptImportOptions.cpp

@@ -8,6 +8,7 @@
 #include "BsTextureImportOptions.h"
 #include "BsFontImportOptions.h"
 #include "BsScriptCodeImportOptions.h"
+#include "BsMeshImportOptions.h"
 #include "BsRenderer.h"
 #include "BsScriptFont.h"
 #include "BsRTTIType.h"
@@ -72,6 +73,10 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_SetGenerateMipmaps", &ScriptTextureImportOptions::internal_SetGenerateMipmaps);
 		metaData.scriptClass->addInternalCall("Internal_GetMaxMipmapLevel", &ScriptTextureImportOptions::internal_GetMaxMipmapLevel);
 		metaData.scriptClass->addInternalCall("Internal_SetMaxMipmapLevel", &ScriptTextureImportOptions::internal_SetMaxMipmapLevel);
+		metaData.scriptClass->addInternalCall("Internal_GetCPUReadable", &ScriptTextureImportOptions::internal_GetCPUReadable);
+		metaData.scriptClass->addInternalCall("Internal_SetCPUReadable", &ScriptTextureImportOptions::internal_SetCPUReadable);
+		metaData.scriptClass->addInternalCall("Internal_GetIsSRGB", &ScriptTextureImportOptions::internal_GetIsSRGB);
+		metaData.scriptClass->addInternalCall("Internal_SetIsSRGB", &ScriptTextureImportOptions::internal_SetIsSRGB);
 	}
 
 	SPtr<TextureImportOptions> ScriptTextureImportOptions::getTexImportOptions()
@@ -128,6 +133,145 @@ namespace BansheeEngine
 		thisPtr->getTexImportOptions()->setMaxMip(value);
 	}
 
+	bool ScriptTextureImportOptions::internal_GetCPUReadable(ScriptTextureImportOptions* thisPtr)
+	{
+		return thisPtr->getTexImportOptions()->getCPUReadable();
+	}
+
+	void ScriptTextureImportOptions::internal_SetCPUReadable(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getTexImportOptions()->setCPUReadable(value);
+	}
+
+	bool ScriptTextureImportOptions::internal_GetIsSRGB(ScriptTextureImportOptions* thisPtr)
+	{
+		return thisPtr->getTexImportOptions()->getSRGB();
+	}
+
+	void ScriptTextureImportOptions::internal_SetIsSRGB(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getTexImportOptions()->setSRGB(value);
+	}
+
+	ScriptMeshImportOptions::ScriptMeshImportOptions(MonoObject* instance)
+		:ScriptObject(instance)
+	{
+		mImportOptions = bs_shared_ptr_new<MeshImportOptions>();
+	}
+
+	void ScriptMeshImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptMeshImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetCPUReadable", &ScriptMeshImportOptions::internal_GetCPUReadable);
+		metaData.scriptClass->addInternalCall("Internal_SetCPUReadable", &ScriptMeshImportOptions::internal_SetCPUReadable);
+		metaData.scriptClass->addInternalCall("Internal_GetImportNormals", &ScriptMeshImportOptions::internal_GetImportNormals);
+		metaData.scriptClass->addInternalCall("Internal_SetImportNormals", &ScriptMeshImportOptions::internal_SetImportNormals);
+		metaData.scriptClass->addInternalCall("Internal_GetImportTangents", &ScriptMeshImportOptions::internal_GetImportTangents);
+		metaData.scriptClass->addInternalCall("Internal_SetImportTangents", &ScriptMeshImportOptions::internal_SetImportTangents);
+		metaData.scriptClass->addInternalCall("Internal_GetImportSkin", &ScriptMeshImportOptions::internal_GetImportSkin);
+		metaData.scriptClass->addInternalCall("Internal_SetImportSkin", &ScriptMeshImportOptions::internal_SetImportSkin);
+		metaData.scriptClass->addInternalCall("Internal_GetImportAnimation", &ScriptMeshImportOptions::internal_GetImportAnimation);
+		metaData.scriptClass->addInternalCall("Internal_SetImportAnimation", &ScriptMeshImportOptions::internal_SetImportAnimation);
+		metaData.scriptClass->addInternalCall("Internal_GetImportBlendShapes", &ScriptMeshImportOptions::internal_GetImportBlendShapes);
+		metaData.scriptClass->addInternalCall("Internal_SetImportBlendShapes", &ScriptMeshImportOptions::internal_SetImportBlendShapes);
+		metaData.scriptClass->addInternalCall("Internal_GetScale", &ScriptMeshImportOptions::internal_GetScale);
+		metaData.scriptClass->addInternalCall("Internal_SetScale", &ScriptMeshImportOptions::internal_SetScale);
+	}
+
+	SPtr<MeshImportOptions> ScriptMeshImportOptions::getMeshImportOptions()
+	{
+		return std::static_pointer_cast<MeshImportOptions>(mImportOptions);
+	}
+
+	MonoObject* ScriptMeshImportOptions::create()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+
+	MonoObject* ScriptMeshImportOptions::create(const SPtr<MeshImportOptions>& options)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		ScriptMeshImportOptions* scriptObj = ScriptMeshImportOptions::toNative(managedInstance);
+		scriptObj->mImportOptions = options;
+
+		return managedInstance;
+	}
+
+	void ScriptMeshImportOptions::internal_CreateInstance(MonoObject* instance)
+	{
+		ScriptMeshImportOptions* nativeInstance = new (bs_alloc<ScriptMeshImportOptions>()) ScriptMeshImportOptions(instance);
+	}
+
+	bool ScriptMeshImportOptions::internal_GetCPUReadable(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getCPUReadable();
+	}
+
+	void ScriptMeshImportOptions::internal_SetCPUReadable(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getMeshImportOptions()->setCPUReadable(value);
+	}
+
+	bool ScriptMeshImportOptions::internal_GetImportNormals(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getImportNormals();
+	}
+
+	void ScriptMeshImportOptions::internal_SetImportNormals(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getMeshImportOptions()->setImportNormals(value);
+	}
+
+	bool ScriptMeshImportOptions::internal_GetImportTangents(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getImportTangents();
+	}
+
+	void ScriptMeshImportOptions::internal_SetImportTangents(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getMeshImportOptions()->setImportTangents(value);
+	}
+
+	bool ScriptMeshImportOptions::internal_GetImportSkin(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getImportSkin();
+	}
+
+	void ScriptMeshImportOptions::internal_SetImportSkin(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getMeshImportOptions()->setImportSkin(value);
+	}
+
+	bool ScriptMeshImportOptions::internal_GetImportAnimation(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getImportAnimation();
+	}
+
+	void ScriptMeshImportOptions::internal_SetImportAnimation(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getMeshImportOptions()->setImportAnimation(value);
+	}
+
+	bool ScriptMeshImportOptions::internal_GetImportBlendShapes(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getImportBlendShapes();
+	}
+
+	void ScriptMeshImportOptions::internal_SetImportBlendShapes(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getMeshImportOptions()->setImportBlendShapes(value);
+	}
+
+	float ScriptMeshImportOptions::internal_GetScale(ScriptMeshImportOptions* thisPtr)
+	{
+		return thisPtr->getMeshImportOptions()->getImportScale();
+	}
+
+	void ScriptMeshImportOptions::internal_SetScale(ScriptMeshImportOptions* thisPtr, float value)
+	{
+		thisPtr->getMeshImportOptions()->setImportScale(value);
+	}
+
 	ScriptFontImportOptions::ScriptFontImportOptions(MonoObject* instance)
 		:ScriptObject(instance)
 	{