Added new platform options to the build system

BansheeEditor/Include/BsBuildManager.h

@@ -25,7 +25,7 @@ namespace BansheeEngine
 	public:
 		friend class BuildDataRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		virtual RTTITypeBase* getRTTI() const override;
 	};
 
 	/**

BansheeEditor/Include/BsPlatformInfo.h

@@ -2,6 +2,7 @@
 
 #include "BsEditorPrerequisites.h"
 #include "BsIReflectable.h"
+#include "BsVideoModeInfo.h"
 
 namespace BansheeEngine
 {
@@ -24,6 +25,10 @@ namespace BansheeEngine
 
 		PlatformType type; /**< Type of platform this object contains data for. */
 		WString defines; /**< A set of semicolon separated defines to use when compiling scripts for this platform. */
+		HPrefab mainScene; /**< Default scene that is loaded when the application is started. */
+		bool fullscreen; /**< If true the application will be started in fullscreen using user's desktop resolution. */
+		UINT32 windowedWidth; /**< Width of the window if not starting the application in fullscreen. */
+		UINT32 windowedHeight; /**< Height of the window if not starting the application in fullscreen. */
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/
@@ -42,7 +47,6 @@ namespace BansheeEngine
 	{
 		WinPlatformInfo();
 
-		bool is32bit;
 		HTexture icon16;
 		HTexture icon32;
 		HTexture icon48;
@@ -51,6 +55,8 @@ namespace BansheeEngine
 		HTexture icon128;
 		HTexture icon192;
 		HTexture icon256;
+		HTexture taskbarIcon;
+		WString titlebarText;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/

BansheeEditor/Include/BsPlatformInfoRTTI.h

@@ -14,11 +14,28 @@ namespace BansheeEngine
 
 		PlatformType& getType(PlatformInfo* obj) { return obj->type; }
 		void setType(PlatformInfo* obj, PlatformType& val) { obj->type = val; }
+
+		HPrefab& getMainScene(PlatformInfo* obj) { return obj->mainScene; }
+		void setMainScene(PlatformInfo* obj, HPrefab& val) { obj->mainScene = val; }
+
+		bool& getFullscreen(PlatformInfo* obj) { return obj->fullscreen; }
+		void setFullscreen(PlatformInfo* obj, bool& val) { obj->fullscreen = val; }
+
+		UINT32& getWindowedWidth(PlatformInfo* obj) { return obj->windowedWidth; }
+		void setWindowedWidth(PlatformInfo* obj, UINT32& val) { obj->windowedWidth = val; }
+
+		UINT32& getWindowedHeight(PlatformInfo* obj) { return obj->windowedHeight; }
+		void setWindowedHeight(PlatformInfo* obj, UINT32& val) { obj->windowedHeight = val; }
+
 	public:
 		PlatformInfoRTTI()
 		{
 			addPlainField("defines", 0, &PlatformInfoRTTI::getDefines, &PlatformInfoRTTI::setDefines);
 			addPlainField("type", 1, &PlatformInfoRTTI::getType, &PlatformInfoRTTI::setType);
+			addReflectableField("mainScene", 2, &PlatformInfoRTTI::getMainScene, &PlatformInfoRTTI::setMainScene);
+			addPlainField("fullscreen", 3, &PlatformInfoRTTI::getFullscreen, &PlatformInfoRTTI::setFullscreen);
+			addPlainField("windowedWidth", 4, &PlatformInfoRTTI::getWindowedWidth, &PlatformInfoRTTI::setWindowedWidth);
+			addPlainField("windowedHeight", 5, &PlatformInfoRTTI::getWindowedHeight, &PlatformInfoRTTI::setWindowedHeight);
 		}
 
 		virtual const String& getRTTIName() override
@@ -41,9 +58,6 @@ namespace BansheeEngine
 	class BS_ED_EXPORT WinPlatformInfoRTTI : public RTTIType <WinPlatformInfo, PlatformInfo, WinPlatformInfoRTTI>
 	{
 	private:
-		bool& getIs32Bit(WinPlatformInfo* obj) { return obj->is32bit; }
-		void setIs32Bit(WinPlatformInfo* obj, bool& val) { obj->is32bit = val; }
-
 		HTexture& getIcon16(WinPlatformInfo* obj) { return obj->icon16; }
 		void setIcon16(WinPlatformInfo* obj, HTexture& val) { obj->icon16 = val; }
 
@@ -68,10 +82,15 @@ namespace BansheeEngine
 		HTexture& getIcon256(WinPlatformInfo* obj) { return obj->icon256; }
 		void setIcon256(WinPlatformInfo* obj, HTexture& val) { obj->icon256 = val; }
 
+		HTexture& getTaskbarIcon(WinPlatformInfo* obj) { return obj->taskbarIcon; }
+		void setTaskbarIcon(WinPlatformInfo* obj, HTexture& val) { obj->taskbarIcon = val; }
+
+		WString& getTitlebarText(WinPlatformInfo* obj) { return obj->titlebarText; }
+		void setTitlebarText(WinPlatformInfo* obj, WString& val) { obj->titlebarText = val; }
+
 	public:
 		WinPlatformInfoRTTI()
 		{
-			addPlainField("is32bit", 0, &WinPlatformInfoRTTI::getIs32Bit, &WinPlatformInfoRTTI::setIs32Bit);
 			addReflectableField("icon16", 1, &WinPlatformInfoRTTI::getIcon16, &WinPlatformInfoRTTI::setIcon16);
 			addReflectableField("icon32", 2, &WinPlatformInfoRTTI::getIcon32, &WinPlatformInfoRTTI::setIcon32);
 			addReflectableField("icon48", 3, &WinPlatformInfoRTTI::getIcon48, &WinPlatformInfoRTTI::setIcon48);
@@ -80,6 +99,8 @@ namespace BansheeEngine
 			addReflectableField("icon128", 6, &WinPlatformInfoRTTI::getIcon128, &WinPlatformInfoRTTI::setIcon128);
 			addReflectableField("icon192", 7, &WinPlatformInfoRTTI::getIcon192, &WinPlatformInfoRTTI::setIcon192);
 			addReflectableField("icon256", 8, &WinPlatformInfoRTTI::getIcon256, &WinPlatformInfoRTTI::setIcon256);
+			addReflectableField("taskbarIcon", 9, &WinPlatformInfoRTTI::getTaskbarIcon, &WinPlatformInfoRTTI::setTaskbarIcon);
+			addPlainField("titlebarText", 10, &WinPlatformInfoRTTI::getTitlebarText, &WinPlatformInfoRTTI::setTitlebarText);
 		}
 
 		virtual const String& getRTTIName() override

BansheeEditor/Source/BsBuildManager.cpp

@@ -76,10 +76,7 @@ namespace BansheeEngine
 		{
 			SPtr<WinPlatformInfo> winPlatformInfo = std::static_pointer_cast<WinPlatformInfo>(getPlatformInfo(type));
 
-			if (winPlatformInfo->is32bit)
-				return "Prebuilt\\Win32\\Game.exe";
-			else
-				return "Prebuilt\\Win64\\Game.exe";
+			return "Prebuilt\\Win64\\Game.exe";
 		}
 		}
 

BansheeEditor/Source/BsPlatformInfo.cpp

@@ -4,7 +4,7 @@
 namespace BansheeEngine
 {
 	PlatformInfo::PlatformInfo()
-		:type(PlatformType::Windows)
+		:type(PlatformType::Windows), fullscreen(true), windowedWidth(1280), windowedHeight(720)
 	{ }
 
 	PlatformInfo::~PlatformInfo()
@@ -21,7 +21,6 @@ namespace BansheeEngine
 	}
 
 	WinPlatformInfo::WinPlatformInfo()
-		:is32bit(true)
 	{ }
 
 	RTTITypeBase* WinPlatformInfo::getRTTIStatic()

MBansheeEditor/BuildManager.cs

@@ -32,6 +32,65 @@ namespace BansheeEditor
             get { return Internal_GetType(mCachedPtr); }
         }
 
+        /// <summary>
+        /// Initial scene that is loaded when application is first started.
+        /// </summary>
+        public Prefab MainScene
+        {
+            get { return Internal_GetMainScene(mCachedPtr); }
+            set
+            {
+                IntPtr scenePtr = IntPtr.Zero;
+                if (value != null)
+                    scenePtr = value.GetCachedPtr();
+
+                Internal_SetMainScene(mCachedPtr, scenePtr);
+            }
+        }
+
+        /// <summary>
+        /// Determines should the application be started in fullscreen using the user's desktop resolution.
+        /// </summary>
+        public bool Fullscreen
+        {
+            get { return Internal_GetFullscreen(mCachedPtr); }
+            set { Internal_SetFullscreen(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Width of a window if the game is started in windowed mode. This is only relevant if <see cref="Fullscreen"/>
+        /// is off.
+        /// </summary>
+        public int WindowedWidth
+        {
+            get
+            {
+                int width, height;
+                Internal_GetResolution(mCachedPtr, out width, out height);
+
+                return width;
+            }
+
+            set { Internal_SetResolution(mCachedPtr, value, WindowedHeight); }
+        }
+
+        /// <summary>
+        /// Height of a window if the game is started in windowed mode. This is only relevant if <see cref="Fullscreen"/>
+        /// is off.
+        /// </summary>
+        public int WindowedHeight
+        {
+            get
+            {
+                int width, height;
+                Internal_GetResolution(mCachedPtr, out width, out height);
+
+                return height;
+            }
+
+            set { Internal_SetResolution(mCachedPtr, WindowedWidth, value); }
+        }
+
         /// <summary>
         /// A set of semicolon separated defines to use when compiling scripts for this platform.
         /// </summary>
@@ -49,6 +108,24 @@ namespace BansheeEditor
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_SetDefines(IntPtr thisPtr, string value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Prefab Internal_GetMainScene(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        static extern void Internal_SetMainScene(IntPtr thisPtr, IntPtr prefabPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        static extern bool Internal_GetFullscreen(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        static extern void Internal_SetFullscreen(IntPtr thisPtr, bool fullscreen);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        static extern void Internal_GetResolution(IntPtr thisPtr, out int width, out int height);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        static extern void Internal_SetResolution(IntPtr thisPtr, int width, int height);
     }
 
     /// <summary>
@@ -72,12 +149,28 @@ namespace BansheeEditor
     public class WinPlatformInfo : PlatformInfo
     {
         /// <summary>
-        /// Determines should the executable be 32 or 64-bit.
+        /// Texture that will be displayed in the taskbar when the application is running.
+        /// </summary>
+        public Texture2D TaskbarIcon
+        {
+            get { return Internal_GetTaskbarIcon(mCachedPtr); }
+            set
+            {
+                IntPtr texturePtr = IntPtr.Zero;
+                if (value != null)
+                    texturePtr = value.GetCachedPtr();
+
+                Internal_SetTaskbarIcon(mCachedPtr, texturePtr);
+            }
+        }
+
+        /// <summary>
+        /// Text that will be displayed in the application's title bar.
         /// </summary>
-        public bool Is32Bit
+        public string TitleText
         {
-            get { return Internal_GetIs32Bit(mCachedPtr); }
-            set { Internal_SetIs32Bit(mCachedPtr, value); }
+            get { return Internal_GetTitleText(mCachedPtr); }
+            set { Internal_SetTitleText(mCachedPtr, value); }
         }
 
         /// <summary>
@@ -105,16 +198,22 @@ namespace BansheeEditor
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetIs32Bit(IntPtr thisPtr);
+        private static extern Texture2D Internal_GetIcon(IntPtr thisPtr, int size);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetIcon(IntPtr thisPtr, int size, IntPtr texturePtr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetIs32Bit(IntPtr thisPtr, bool value);
+        private static extern Texture2D Internal_GetTaskbarIcon(IntPtr thisPtr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Texture2D Internal_GetIcon(IntPtr thisPtr, int size);
+        private static extern void Internal_SetTaskbarIcon(IntPtr thisPtr, IntPtr texturePtr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetIcon(IntPtr thisPtr, int size, IntPtr texturePtr);
+        private static extern string Internal_GetTitleText(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetTitleText(IntPtr thisPtr, string value);
     }
 
     /// <summary>

SBansheeEditor/Include/BsScriptPlatformInfo.h

@@ -47,6 +47,12 @@ namespace BansheeEngine
 		static PlatformType internal_GetType(ScriptPlatformInfoBase* thisPtr);
 		static MonoString* internal_GetDefines(ScriptPlatformInfoBase* thisPtr);
 		static void internal_SetDefines(ScriptPlatformInfoBase* thisPtr, MonoString* value);
+		static MonoObject* internal_GetMainScene(ScriptPlatformInfoBase* thisPtr);
+		static void internal_SetMainScene(ScriptPlatformInfoBase* thisPtr, ScriptPrefab* prefabPtr);
+		static bool internal_GetFullscreen(ScriptPlatformInfoBase* thisPtr);
+		static void internal_SetFullscreen(ScriptPlatformInfoBase* thisPtr, bool fullscreen);
+		static void internal_GetResolution(ScriptPlatformInfoBase* thisPtr, UINT32* width, UINT32* height);
+		static void internal_SetResolution(ScriptPlatformInfoBase* thisPtr, UINT32 width, UINT32 height);
 	};
 
 	/**
@@ -74,9 +80,11 @@ namespace BansheeEngine
 		/************************************************************************/
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
-		static bool internal_GetIs32Bit(ScriptWinPlatformInfo* thisPtr);
-		static void internal_SetIs32Bit(ScriptWinPlatformInfo* thisPtr, bool value);
 		static MonoObject* internal_GetIcon(ScriptWinPlatformInfo* thisPtr, int size);
-		static void Internal_SetIcon(ScriptWinPlatformInfo* thisPtr, int size, ScriptTexture2D* texturePtr);
+		static void internal_SetIcon(ScriptWinPlatformInfo* thisPtr, int size, ScriptTexture2D* texturePtr);
+		static MonoObject* internal_GetTaskbarIcon(ScriptWinPlatformInfo* thisPtr);
+		static void internal_SetTaskbarIcon(ScriptWinPlatformInfo* thisPtr, ScriptTexture2D* texturePtr);
+		static MonoString* internal_GetTitleText(ScriptWinPlatformInfo* thisPtr);
+		static void internal_SetTitleText(ScriptWinPlatformInfo* thisPtr, MonoString* text);
 	};
 }

SBansheeEditor/Source/BsScriptPlatformInfo.cpp

@@ -7,6 +7,7 @@
 #include "BsMonoUtil.h"
 #include "BsScriptTexture2D.h"
 #include "BsScriptResourceManager.h"
+#include "BsScriptPrefab.h"
 
 namespace BansheeEngine
 {
@@ -25,6 +26,12 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_GetType", &ScriptPlatformInfo::internal_GetType);
 		metaData.scriptClass->addInternalCall("Internal_GetDefines", &ScriptPlatformInfo::internal_GetDefines);
 		metaData.scriptClass->addInternalCall("Internal_SetDefines", &ScriptPlatformInfo::internal_SetDefines);
+		metaData.scriptClass->addInternalCall("Internal_GetMainScene", &ScriptPlatformInfo::internal_GetMainScene);
+		metaData.scriptClass->addInternalCall("Internal_SetMainScene", &ScriptPlatformInfo::internal_SetMainScene);
+		metaData.scriptClass->addInternalCall("Internal_GetFullscreen", &ScriptPlatformInfo::internal_GetFullscreen);
+		metaData.scriptClass->addInternalCall("Internal_SetFullscreen", &ScriptPlatformInfo::internal_SetFullscreen);
+		metaData.scriptClass->addInternalCall("Internal_GetResolution", &ScriptPlatformInfo::internal_GetResolution);
+		metaData.scriptClass->addInternalCall("Internal_SetResolution", &ScriptPlatformInfo::internal_SetResolution);
 	}
 
 	MonoObject* ScriptPlatformInfo::create(const SPtr<PlatformInfo>& platformInfo)
@@ -54,6 +61,53 @@ namespace BansheeEngine
 		thisPtr->getPlatformInfo()->defines = MonoUtil::monoToWString(value);
 	}
 
+	MonoObject* ScriptPlatformInfo::internal_GetMainScene(ScriptPlatformInfoBase* thisPtr)
+	{
+		HPrefab prefab = thisPtr->getPlatformInfo()->mainScene;
+
+		if (prefab != nullptr)
+		{
+			ScriptPrefab* scriptPrefab;
+			ScriptResourceManager::instance().getScriptResource(prefab, &scriptPrefab, true);
+
+			return scriptPrefab->getManagedInstance();
+		}
+
+		return nullptr;
+	}
+
+	void ScriptPlatformInfo::internal_SetMainScene(ScriptPlatformInfoBase* thisPtr, ScriptPrefab* prefabPtr)
+	{
+		HPrefab prefab;
+
+		if (prefabPtr != nullptr)
+			prefab = prefabPtr->getHandle();
+
+		thisPtr->getPlatformInfo()->mainScene = prefab;
+	}
+
+	bool ScriptPlatformInfo::internal_GetFullscreen(ScriptPlatformInfoBase* thisPtr)
+	{
+		return thisPtr->getPlatformInfo()->fullscreen;
+	}
+
+	void ScriptPlatformInfo::internal_SetFullscreen(ScriptPlatformInfoBase* thisPtr, bool fullscreen)
+	{
+		thisPtr->getPlatformInfo()->fullscreen = fullscreen;
+	}
+
+	void ScriptPlatformInfo::internal_GetResolution(ScriptPlatformInfoBase* thisPtr, UINT32* width, UINT32* height)
+	{
+		*width = thisPtr->getPlatformInfo()->windowedWidth;
+		*height = thisPtr->getPlatformInfo()->windowedHeight;
+	}
+
+	void ScriptPlatformInfo::internal_SetResolution(ScriptPlatformInfoBase* thisPtr, UINT32 width, UINT32 height)
+	{
+		thisPtr->getPlatformInfo()->windowedWidth = width;
+		thisPtr->getPlatformInfo()->windowedHeight = height;
+	}
+
 	ScriptWinPlatformInfo::ScriptWinPlatformInfo(MonoObject* instance)
 		:ScriptObject(instance)
 	{
@@ -62,10 +116,12 @@ namespace BansheeEngine
 
 	void ScriptWinPlatformInfo::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetIs32Bit", &ScriptWinPlatformInfo::internal_GetIs32Bit);
-		metaData.scriptClass->addInternalCall("Internal_SetIs32Bit", &ScriptWinPlatformInfo::internal_SetIs32Bit);
 		metaData.scriptClass->addInternalCall("Internal_GetIcon", &ScriptWinPlatformInfo::internal_GetIcon);
-		metaData.scriptClass->addInternalCall("Internal_SetIcon", &ScriptWinPlatformInfo::Internal_SetIcon);
+		metaData.scriptClass->addInternalCall("Internal_SetIcon", &ScriptWinPlatformInfo::internal_SetIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetTaskbarIcon", &ScriptWinPlatformInfo::internal_GetTaskbarIcon);
+		metaData.scriptClass->addInternalCall("Internal_SetTaskbarIcon", &ScriptWinPlatformInfo::internal_SetTaskbarIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetTitleText", &ScriptWinPlatformInfo::internal_GetTitleText);
+		metaData.scriptClass->addInternalCall("Internal_SetTitleText", &ScriptWinPlatformInfo::internal_SetTitleText);
 	}
 
 	SPtr<WinPlatformInfo> ScriptWinPlatformInfo::getWinPlatformInfo() const
@@ -82,16 +138,6 @@ namespace BansheeEngine
 		return managedInstance;
 	}
 
-	bool ScriptWinPlatformInfo::internal_GetIs32Bit(ScriptWinPlatformInfo* thisPtr)
-	{
-		return thisPtr->getWinPlatformInfo()->is32bit;
-	}
-
-	void ScriptWinPlatformInfo::internal_SetIs32Bit(ScriptWinPlatformInfo* thisPtr, bool value)
-	{
-		thisPtr->getWinPlatformInfo()->is32bit = value;
-	}
-
 	MonoObject* ScriptWinPlatformInfo::internal_GetIcon(ScriptWinPlatformInfo* thisPtr, int size)
 	{
 		HTexture icon;
@@ -134,7 +180,7 @@ namespace BansheeEngine
 		return nullptr;
 	}
 
-	void ScriptWinPlatformInfo::Internal_SetIcon(ScriptWinPlatformInfo* thisPtr, int size, ScriptTexture2D* texturePtr)
+	void ScriptWinPlatformInfo::internal_SetIcon(ScriptWinPlatformInfo* thisPtr, int size, ScriptTexture2D* texturePtr)
 	{
 		HTexture icon;
 
@@ -169,4 +215,43 @@ namespace BansheeEngine
 			break;
 		}
 	}
+
+	MonoObject* ScriptWinPlatformInfo::internal_GetTaskbarIcon(ScriptWinPlatformInfo* thisPtr)
+	{
+		HTexture icon = thisPtr->getWinPlatformInfo()->taskbarIcon;
+
+		if (icon != nullptr)
+		{
+			ScriptTexture2D* scriptTexture;
+			ScriptResourceManager::instance().getScriptResource(icon, &scriptTexture, true);
+
+			return scriptTexture->getManagedInstance();
+		}
+
+		return nullptr;
+	}
+
+	void ScriptWinPlatformInfo::internal_SetTaskbarIcon(ScriptWinPlatformInfo* thisPtr, ScriptTexture2D* texturePtr)
+	{
+		HTexture icon;
+
+		if (texturePtr != nullptr)
+			icon = texturePtr->getHandle();
+
+		thisPtr->getWinPlatformInfo()->taskbarIcon = icon;
+	}
+
+	MonoString* ScriptWinPlatformInfo::internal_GetTitleText(ScriptWinPlatformInfo* thisPtr)
+	{
+		WString titleText = thisPtr->getWinPlatformInfo()->titlebarText;
+
+		return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), titleText);
+	}
+
+	void ScriptWinPlatformInfo::internal_SetTitleText(ScriptWinPlatformInfo* thisPtr, MonoString* text)
+	{
+		WString titleText = MonoUtil::monoToWString(text);
+
+		thisPtr->getWinPlatformInfo()->titlebarText = titleText;
+	}
 }