Added basic tool window creation to all render systems

Fixed up multi-monitor support when creating DX11 render window

CamelotClient/CamelotClient.cpp

@@ -25,12 +25,14 @@
 
 #include "CmDebugCamera.h"
 #include "CmTestTextSprite.h"
+#include "CmEditorWindow.h"
 
 #define DX11
 //#define DX9
 //#define GL
 
 using namespace CamelotEngine;
+using namespace CamelotEditor;
 
 int CALLBACK WinMain(
 	_In_  HINSTANCE hInstance,
@@ -66,8 +68,8 @@ int CALLBACK WinMain(
 	HSceneObject testModelGO = SceneObject::create("TestMesh");
 	HRenderable testRenderable = testModelGO->addComponent<Renderable>();
 
-	HSceneObject testTextGO = SceneObject::create("TestText");
-	GameObjectHandle<TestTextSprite> textSprite = testTextGO->addComponent<TestTextSprite>();
+	//HSceneObject testTextGO = SceneObject::create("TestText");
+	//GameObjectHandle<TestTextSprite> textSprite = testTextGO->addComponent<TestTextSprite>();
 
 	HFont font;
 	
@@ -85,7 +87,7 @@ int CALLBACK WinMain(
 		font = Importer::instance().import("C:\\arial.ttf", fontImportOptions);
 	}
 
-	textSprite->setText(camera, "Testing in a new row, does this work?", font, 12);
+	//textSprite->setText(camera, "Testing in a new row, does this work?", font, 12);
 
 #if defined DX9
 	///////////////// HLSL 9 SHADERS //////////////////////////
@@ -274,11 +276,15 @@ int CALLBACK WinMain(
 
 	//// Set the new state for the flag
 	//_CrtSetDbgFlag( tmpFlag );
+	
+	EditorWindow* newWindow = new EditorWindow("Test window");
 
 	gApplication().runMainLoop();
 
 	// Release everything before shutdown
 	
+	delete newWindow;
+
 	//testMaterial->destroy();
 #ifdef DX11
 	gpuProgInclude.reset();

CamelotClient/CmEditorWindow.cpp

@@ -1,5 +1,6 @@
 #include "CmEditorWindow.h"
 #include "CmRenderWindow.h"
+#include "CmApplication.h"
 
 namespace CamelotEditor
 {
@@ -10,8 +11,10 @@ namespace CamelotEditor
 		renderWindowDesc.height = 720;
 		renderWindowDesc.title = "EditorWindow";
 		renderWindowDesc.fullscreen = false;
+		renderWindowDesc.border = WindowBorder::None;
+		renderWindowDesc.toolWindow = true;
 
-		mRenderWindow = RenderWindow::create(renderWindowDesc);
+		mRenderWindow = RenderWindow::create(renderWindowDesc, gApplication().getPrimaryRenderWindow());
 	}
 
 	EditorWindow::~EditorWindow()

CamelotCore/Include/CmRenderWindow.h

@@ -32,6 +32,13 @@ THE SOFTWARE
 
 namespace CamelotEngine
 {
+	enum class WindowBorder
+	{
+		Normal,
+		None,
+		Fixed
+	};
+
 	struct CM_EXPORT RENDER_WINDOW_DESC
 	{
 		RENDER_WINDOW_DESC()
@@ -39,8 +46,8 @@ namespace CamelotEngine
 			, vsync(false), vsyncInterval(1), hidden(false)
 			, displayFrequency(60), colorDepth(32), depthBuffer(true)
 			, FSAA(0), FSAAHint(""), gamma(false), left(-1), top(-1)
-			, title(""), border(""), outerDimensions(false), enableDoubleClick(false)
-			, monitorIndex(-1)
+			, title(""), border(WindowBorder::Normal), outerDimensions(false), enableDoubleClick(false)
+			, monitorIndex(-1), toolWindow(false)
 		{ }
 
 		UINT32 width;
@@ -58,9 +65,10 @@ namespace CamelotEngine
 		INT32 left; // -1 == screen center
 		INT32 top; // -1 == screen center
 		String title;
-		String border;
+		WindowBorder border;
 		bool outerDimensions;
 		bool enableDoubleClick;
+		bool toolWindow;
 		UINT32 monitorIndex; // -1 == select based on coordinates
 
 		NameValuePairList platformSpecific;
@@ -167,7 +175,7 @@ namespace CamelotEngine
           */
         void setDeactivateOnFocusChange(bool deactivate);
 
-		static RenderWindowPtr create(const RENDER_WINDOW_DESC& desc);
+		static RenderWindowPtr create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow = nullptr);
 
     protected:
         /** Default constructor.

CamelotCore/Include/CmRenderWindowManager.h

@@ -11,9 +11,9 @@ namespace CamelotEngine
 	public:
 		/** Creates a new rendering window.
 		*/
-		RenderWindowPtr create(const RENDER_WINDOW_DESC& desc);
+		RenderWindowPtr create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
 	protected:
-		virtual RenderWindowPtr createImpl(const RENDER_WINDOW_DESC& desc) = 0;
+		virtual RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow) = 0;
 	};
 }

CamelotCore/Source/CmRenderWindow.cpp

@@ -36,7 +36,7 @@ namespace CamelotEngine
 		, mIsFullScreen(false)
 		, mDesc(desc)
     {
-        mAutoDeactivatedOnFocusChange = true;
+        mAutoDeactivatedOnFocusChange = false;
     }
 
 	RenderWindow::~RenderWindow() 
@@ -70,8 +70,8 @@ namespace CamelotEngine
         mAutoDeactivatedOnFocusChange = deactivate;
     }
 
-	RenderWindowPtr RenderWindow::create(const RENDER_WINDOW_DESC& desc)
+	RenderWindowPtr RenderWindow::create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
-		return RenderWindowManager::instance().create(desc);
+		return RenderWindowManager::instance().create(desc, parentWindow);
 	}
 }

CamelotCore/Source/CmRenderWindowManager.cpp

@@ -2,9 +2,9 @@
 
 namespace CamelotEngine
 {
-	RenderWindowPtr RenderWindowManager::create(const RENDER_WINDOW_DESC& desc)
+	RenderWindowPtr RenderWindowManager::create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
-		RenderWindowPtr renderWindow = createImpl(desc);
+		RenderWindowPtr renderWindow = createImpl(desc, parentWindow);
 		renderWindow->setThisPtr(renderWindow);
 		renderWindow->initialize();
 

CamelotD3D11RenderSystem/Include/CmD3D11Driver.h

@@ -16,10 +16,11 @@ namespace CamelotEngine
 		String getDriverName() const;
 		String getDriverDescription() const;
 		UINT32 getAdapterNumber() const { return mAdapterNumber; }
-		UINT32 getNumAdapterOutputs() const;
+		UINT32 getNumAdapterOutputs() const { return mNumOutputs; }
 		const DXGI_ADAPTER_DESC& getAdapterIdentifier() const { return mAdapterIdentifier; }
 		const DXGI_MODE_DESC& getDesktopMode() const { return mDesktopDisplayMode; }
 		IDXGIAdapter* getDeviceAdapter() { return mDXGIAdapter; }
+		DXGI_OUTPUT_DESC getOutputDesc(UINT32 adapterOutputIdx) const;
 		const D3D11VideoModeList* getVideoModeList(UINT32 adapterOutputIdx) const;
 
 	private:

CamelotD3D11RenderSystem/Include/CmD3D11RenderSystem.h

@@ -78,6 +78,11 @@ namespace CamelotEngine
 		IDXGIFactory* getDXGIFactory() const { return mDXGIFactory; }
 		D3D11Device& getPrimaryDevice() const { return *mDevice; }
 		
+		/**
+		 * @brief	Returns a total number of outputs (e.g. monitors), across all adapters.
+		 */
+		D3D11DriverList* getDriverList() const { return mDriverList; }
+
 	protected:
 		friend class D3D11RenderSystemFactory;
 		D3D11RenderSystem();

CamelotD3D11RenderSystem/Include/CmD3D11RenderWindowManager.h

@@ -14,7 +14,7 @@ namespace CamelotEngine
 		/**
 		 * @copydoc RenderWindowManager::createImpl()
 		 */
-		RenderWindowPtr createImpl(const RENDER_WINDOW_DESC& desc);
+		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
 	private:
 		D3D11RenderSystem* mRenderSystem;

CamelotD3D11RenderSystem/Source/CmD3D11Driver.cpp

@@ -1,5 +1,6 @@
 #include "CmD3D11Driver.h"
 #include "CmD3D11VideoModeList.h"
+#include "CmException.h"
 
 namespace CamelotEngine
 {
@@ -51,10 +52,11 @@ namespace CamelotEngine
 		assert(mDXGIAdapter != nullptr);
 
 		UINT32 outputIdx = 0;
-		IDXGIOutput* output;
+		IDXGIOutput* output = nullptr;
 		while(mDXGIAdapter->EnumOutputs(outputIdx, &output) != DXGI_ERROR_NOT_FOUND)
 		{
 			outputIdx++;
+			SAFE_RELEASE(output);
 		}
 
 		mNumOutputs = outputIdx;
@@ -114,4 +116,21 @@ namespace CamelotEngine
 
 		return mVideoModeList[adapterOutputIdx];
 	}
+
+	DXGI_OUTPUT_DESC D3D11Driver::getOutputDesc(UINT32 adapterOutputIdx) const
+	{
+		DXGI_OUTPUT_DESC desc;
+		
+		IDXGIOutput* output = nullptr;
+		if(mDXGIAdapter->EnumOutputs(adapterOutputIdx, &output) == DXGI_ERROR_NOT_FOUND)
+		{
+			CM_EXCEPT(InvalidParametersException, "Cannot find output with the specified index: " + toString(adapterOutputIdx));
+		}
+
+		output->GetDesc(&desc);
+
+		SAFE_RELEASE(output);
+
+		return desc;
+	}
 }

CamelotD3D11RenderSystem/Source/CmD3D11RenderWindow.cpp

@@ -5,6 +5,8 @@
 #include "CmD3D11RenderTexture.h"
 #include "CmD3D11TextureView.h"
 #include "CmTextureManager.h"
+#include "CmD3D11DriverList.h"
+#include "CmD3D11Driver.h"
 #include "CmException.h"
 
 namespace CamelotEngine
@@ -42,6 +44,7 @@ namespace CamelotEngine
 		mVSyncInterval = 1;
 		HWND parentHWnd = 0;
 		HWND externalHandle = 0;
+		HMONITOR hMonitor = NULL;
 
 		// Get variable-length params
 		NameValuePairList::const_iterator opt;
@@ -54,6 +57,10 @@ namespace CamelotEngine
 		opt = mDesc.platformSpecific.find("externalWindowHandle");
 		if(opt != mDesc.platformSpecific.end())
 			externalHandle = (HWND)parseUnsignedInt(opt->second);
+		// monitor handle
+		opt = mDesc.platformSpecific.find("monitorHandle");
+		if (opt != mDesc.platformSpecific.end())
+			hMonitor = (HMONITOR)parseInt(opt->second);		
 
 		mName = mDesc.title;
 		mIsFullScreen = mDesc.fullscreen;
@@ -66,24 +73,112 @@ namespace CamelotEngine
 		if (!externalHandle)
 		{
 			DWORD dwStyle = (mHidden ? 0 : WS_VISIBLE) | WS_CLIPCHILDREN;
+			DWORD dwStyleEx = 0;
 			RECT rc;
+			MONITORINFO monitorInfo;
+
+			// If we specified which adapter we want to use - find it's monitor.
+			if (mDesc.monitorIndex != -1)
+			{
+				RenderSystem* rs = RenderSystem::instancePtr();
+				D3D11RenderSystem* d3d11rs = static_cast<D3D11RenderSystem*>(rs);
+
+				D3D11DriverList* driverList = d3d11rs->getDriverList();
+
+				UINT32 curOutput = 0;
+				for(UINT32 i = 0; i < driverList->count(); i++)
+				{
+					D3D11Driver* driver = driverList->item(i);
+					UINT32 numOutputs = driver->getNumAdapterOutputs();
+
+					for(UINT32 j = 0; j < numOutputs; j++)
+					{
+						if(curOutput == mDesc.monitorIndex)
+						{
+							hMonitor = driver->getOutputDesc(j).Monitor;
+							break;
+						}
+
+						curOutput++;
+					}
+
+					if(curOutput == mDesc.monitorIndex)
+						break;
+				}			
+			}
+
+			// If we didn't specified the adapter index, or if it didn't find it
+			if (hMonitor == NULL)
+			{
+				POINT windowAnchorPoint;
+
+				// Fill in anchor point.
+				windowAnchorPoint.x = mDesc.left;
+				windowAnchorPoint.y = mDesc.top;
+
+				// Get the nearest monitor to this window.
+				hMonitor = MonitorFromPoint(windowAnchorPoint, MONITOR_DEFAULTTOPRIMARY);
+			}
+
+			// Get the target monitor info		
+			memset(&monitorInfo, 0, sizeof(MONITORINFO));
+			monitorInfo.cbSize = sizeof(MONITORINFO);
+			GetMonitorInfo(hMonitor, &monitorInfo);
+
+
+			unsigned int winWidth, winHeight;
+			winWidth = mDesc.width;
+			winHeight = mDesc.height;
+
+			UINT32 left = mDesc.left;
+			UINT32 top = mDesc.top;
+
+			// No specified top left -> Center the window in the middle of the monitor
+			if (left == -1 || top == -1)
+			{				
+				int screenw = monitorInfo.rcWork.right  - monitorInfo.rcWork.left;
+				int screenh = monitorInfo.rcWork.bottom - monitorInfo.rcWork.top;
+
+				// clamp window dimensions to screen size
+				int outerw = (int(winWidth) < screenw)? int(winWidth) : screenw;
+				int outerh = (int(winHeight) < screenh)? int(winHeight) : screenh;
+
+				if (left == -1)
+					left = monitorInfo.rcWork.left + (screenw - outerw) / 2;
+				else if (mDesc.monitorIndex != -1)
+					left += monitorInfo.rcWork.left;
+
+				if (top == -1)
+					top = monitorInfo.rcWork.top + (screenh - outerh) / 2;
+				else if (mDesc.monitorIndex != -1)
+					top += monitorInfo.rcWork.top;
+			}
+			else if (mDesc.monitorIndex != -1)
+			{
+				left += monitorInfo.rcWork.left;
+				top += monitorInfo.rcWork.top;
+			}
 
 			mWidth = mDesc.width;
 			mHeight = mDesc.height;
-			mTop = mDesc.top;
-			mLeft = mDesc.left;
+			mTop = top;
+			mLeft = left;
 
 			if (!mDesc.fullscreen)
 			{
 				if (parentHWnd)
 				{
-					dwStyle |= WS_CHILD;
+					if(mDesc.toolWindow)
+						dwStyleEx = WS_EX_TOOLWINDOW;
+					else
+						dwStyle |= WS_CHILD;
 				}
-				else
+
+				if (!parentHWnd || mDesc.toolWindow)
 				{
-					if (mDesc.border == "none")
+					if (mDesc.border == WindowBorder::None)
 						dwStyle |= WS_POPUP;
-					else if (mDesc.border == "fixed")
+					else if (mDesc.border == WindowBorder::Fixed)
 						dwStyle |= WS_OVERLAPPED | WS_BORDER | WS_CAPTION |
 						WS_SYSMENU | WS_MINIMIZEBOX;
 					else
@@ -135,7 +230,7 @@ namespace CamelotEngine
 			// Create our main window
 			// Pass pointer to self
 			mIsExternal = false;
-			mHWnd = CreateWindow("D3D11Wnd", mDesc.title.c_str(), dwStyle,
+			mHWnd = CreateWindowEx(dwStyleEx, "D3D11Wnd", mDesc.title.c_str(), dwStyle,
 				mLeft, mTop, mWidth, mHeight, parentHWnd, 0, hInst, this);
 
 			WindowEventUtilities::_addRenderWindow(this);

CamelotD3D11RenderSystem/Source/CmD3D11RenderWindowManager.cpp

@@ -11,11 +11,18 @@ namespace CamelotEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	RenderWindowPtr D3D11RenderWindowManager::createImpl(const RENDER_WINDOW_DESC& desc)
+	RenderWindowPtr D3D11RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
 		RenderSystem* rs = RenderSystem::instancePtr();
 		D3D11RenderSystem* d3d11rs = static_cast<D3D11RenderSystem*>(rs);
 
+		if(parentWindow != nullptr)
+		{
+			HWND hWnd;
+			parentWindow->getCustomAttribute("WINDOW", &hWnd);
+			desc.platformSpecific["parentWindowHandle"] = toString((unsigned long)hWnd);
+		}
+
 		// Create the window
 		D3D11RenderWindow* renderWindow = CM_NEW(D3D11RenderWindow, PoolAlloc) D3D11RenderWindow(desc, d3d11rs->getPrimaryDevice(), d3d11rs->getDXGIFactory());
 		return RenderWindowPtr(renderWindow, &CoreObject::_deleteDelayed<D3D11RenderWindow, PoolAlloc>);

CamelotD3D9Renderer/Include/CmD3D9RenderWindowManager.h

@@ -14,7 +14,7 @@ namespace CamelotEngine
 		/**
 		 * @copydoc RenderWindowManager::createImpl()
 		 */
-		RenderWindowPtr createImpl(const RENDER_WINDOW_DESC& desc);
+		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
 	private:
 		D3D9RenderSystem* mRenderSystem;

CamelotD3D9Renderer/Source/CmD3D9RenderWindow.cpp

@@ -169,13 +169,17 @@ namespace CamelotEngine
 			{
 				if (parentHWnd)
 				{
-					dwStyle |= WS_CHILD;
+					if(mDesc.toolWindow)
+						dwStyleEx = WS_EX_TOOLWINDOW;
+					else
+						dwStyle |= WS_CHILD;
 				}
-				else
+
+				if (!parentHWnd || mDesc.toolWindow)
 				{
-					if (mDesc.border == "none")
+					if (mDesc.border == WindowBorder::None)
 						dwStyle |= WS_POPUP;
-					else if (mDesc.border == "fixed")
+					else if (mDesc.border == WindowBorder::Fixed)
 						dwStyle |= WS_OVERLAPPED | WS_BORDER | WS_CAPTION |
 						WS_SYSMENU | WS_MINIMIZEBOX;
 					else

CamelotD3D9Renderer/Source/CmD3D9RenderWindowManager.cpp

@@ -11,8 +11,15 @@ namespace CamelotEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	RenderWindowPtr D3D9RenderWindowManager::createImpl(const RENDER_WINDOW_DESC& desc)
+	RenderWindowPtr D3D9RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
+		if(parentWindow != nullptr)
+		{
+			HWND hWnd;
+			parentWindow->getCustomAttribute("WINDOW", &hWnd);
+			desc.platformSpecific["parentWindowHandle"] = toString((unsigned long)hWnd);
+		}
+
 		D3D9RenderWindow* window = CM_NEW(D3D9RenderWindow, PoolAlloc) D3D9RenderWindow(desc, mRenderSystem->getInstanceHandle());
 
 		return RenderWindowPtr(window, &CoreObject::_deleteDelayed<D3D9RenderWindow, PoolAlloc>);

CamelotGLRenderer/Include/CmGLRenderWindowManager.h

@@ -14,7 +14,7 @@ namespace CamelotEngine
 		/**
 		 * @copydoc RenderWindowManager::createImpl()
 		 */
-		RenderWindowPtr createImpl(const RENDER_WINDOW_DESC& desc);
+		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
 	private:
 		GLRenderSystem* mRenderSystem;

CamelotGLRenderer/Include/CmGLSupport.h

@@ -42,7 +42,7 @@ public:
     GLSupport() { }
     virtual ~GLSupport() { }
 
-	virtual RenderWindowPtr newWindow(const RENDER_WINDOW_DESC& desc) = 0;
+	virtual RenderWindowPtr newWindow(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow) = 0;
 
     virtual bool supportsPBuffers();
 

CamelotGLRenderer/Include/CmWin32GLSupport.h

@@ -14,7 +14,7 @@ namespace CamelotEngine
         Win32GLSupport();
 
 		/// @copydoc RenderSystem::_createRenderWindow
-		virtual RenderWindowPtr newWindow(const RENDER_WINDOW_DESC& desc);
+		virtual RenderWindowPtr newWindow(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
 		/**
 		* Start anything special

CamelotGLRenderer/Source/CmGLRenderWindowManager.cpp

@@ -11,11 +11,11 @@ namespace CamelotEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	RenderWindowPtr GLRenderWindowManager::createImpl(const RENDER_WINDOW_DESC& desc)
+	RenderWindowPtr GLRenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
 		GLSupport* glSupport = mRenderSystem->getGLSupport();
 
 		// Create the window
-		return glSupport->newWindow(desc);
+		return glSupport->newWindow(desc, parentWindow);
 	}
 }

CamelotGLRenderer/Source/CmWin32GLSupport.cpp

@@ -56,8 +56,15 @@ namespace CamelotEngine
 		return TRUE;
 	}
 
-	RenderWindowPtr Win32GLSupport::newWindow(const RENDER_WINDOW_DESC& desc)
+	RenderWindowPtr Win32GLSupport::newWindow(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{		
+		if(parentWindow != nullptr)
+		{
+			HWND hWnd;
+			parentWindow->getCustomAttribute("WINDOW", &hWnd);
+			desc.platformSpecific["parentWindowHandle"] = toString((unsigned long)hWnd);
+		}
+
 		Win32Window* window = CM_NEW(Win32Window, PoolAlloc) Win32Window(desc, *this);
 		
 		// TODO - Looking for monitors is disabled for now, as it should be done on the render thread and I need to port it but 

CamelotGLRenderer/Source/CmWin32Window.cpp

@@ -202,13 +202,17 @@ namespace CamelotEngine {
 			{				
 				if (parent)
 				{
-					dwStyle |= WS_CHILD;
+					if(mDesc.toolWindow)
+						dwStyleEx = WS_EX_TOOLWINDOW;
+					else
+						dwStyle |= WS_CHILD;
 				}
-				else
+
+				if (!parent || mDesc.toolWindow)
 				{
-					if (mDesc.border == "none")
+					if (mDesc.border == WindowBorder::None)
 						dwStyle |= WS_POPUP;
-					else if (mDesc.border == "fixed")
+					else if (mDesc.border == WindowBorder::Fixed)
 						dwStyle |= WS_OVERLAPPED | WS_BORDER | WS_CAPTION |
 						WS_SYSMENU | WS_MINIMIZEBOX;
 					else