Fixing an issue where core window operations could start before the sim thread had properly finalized window creation

Modified profiler so it doesn't take such a long time estimating overhead

BansheeCore/Include/BsRenderWindow.h

@@ -117,7 +117,7 @@ namespace BansheeEngine
 	class BS_CORE_EXPORT RenderWindowCore : public RenderTargetCore
 	{
 	public:
-		RenderWindowCore(const RENDER_WINDOW_DESC& desc);
+		RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
 		virtual ~RenderWindowCore();
 
 		/** 
@@ -250,6 +250,7 @@ namespace BansheeEngine
 
 		RENDER_WINDOW_DESC mDesc;
 		SpinLock mLock;
+		UINT32 mWindowId;
 	};
 
 	/**
@@ -349,7 +350,7 @@ namespace BansheeEngine
     protected:
 		friend class RenderWindowManager;
 
-		RenderWindow(const RENDER_WINDOW_DESC& desc);
+		RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
 
 		/**
 		 * @brief	Returns render window properties that may be edited.
@@ -368,5 +369,6 @@ namespace BansheeEngine
 
 	protected:
 		RENDER_WINDOW_DESC mDesc;
+		UINT32 mWindowId;
     };
 }

BansheeCore/Include/BsRenderWindowManager.h

@@ -101,12 +101,11 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	create
 		 */
-		virtual RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow) = 0;
+		virtual RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow) = 0;
 
 	protected:
 		BS_MUTEX(mWindowMutex);
-		Vector<RenderWindow*> mCreatedWindows;
-		Map<const RenderWindowCore*, RenderWindow*> mCoreToNonCoreMap;
+		Map<UINT32, RenderWindow*> mWindows;
 
 		RenderWindow* mWindowInFocus;
 		RenderWindow* mNewWindowInFocus;
@@ -123,6 +122,8 @@ namespace BansheeEngine
 	class BS_CORE_EXPORT RenderWindowCoreManager : public Module<RenderWindowCoreManager>
 	{
 	public:
+		RenderWindowCoreManager();
+
 		/**
 		 * @copydoc	RenderWindowCoreManager::create
 		 */
@@ -148,11 +149,12 @@ namespace BansheeEngine
 	protected:
 		friend class RenderWindowCore;
 		friend class RenderWindow;
+		friend class RenderWindowManager;
 
 		/**
 		 * @copydoc	create
 		 */
-		virtual SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc) = 0;
+		virtual SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) = 0;
 
 		/**
 		 * @brief	Called whenever a window is created.
@@ -167,5 +169,6 @@ namespace BansheeEngine
 		BS_MUTEX(mWindowMutex);
 		Vector<RenderWindowCore*> mCreatedWindows;
 		UnorderedSet<RenderWindowCore*> mDirtyProperties;
+		std::atomic_uint mNextWindowId;
 	};
 }

BansheeCore/Source/BsProfilerCPU.cpp

@@ -711,7 +711,7 @@ namespace BansheeEngine
 	void ProfilerCPU::estimateTimerOverhead()
 	{
 		// Get an idea of how long timer calls and RDTSC takes
-		const UINT32 reps = 1000, sampleReps = 100;
+		const UINT32 reps = 1000, sampleReps = 20;
 
 		mBasicTimerOverhead = 1000000.0;
 		mPreciseTimerOverhead = 1000000;
@@ -744,7 +744,7 @@ namespace BansheeEngine
 		mPreciseSamplingOverheadMs = 1000000.0;
 		mBasicSamplingOverheadCycles = 1000000;
 		mPreciseSamplingOverheadCycles = 1000000;
-		for (UINT32 tries = 0; tries < 20; tries++) 
+		for (UINT32 tries = 0; tries < 3; tries++) 
 		{
 			/************************************************************************/
 			/* 				AVERAGE TIME IN MS FOR BASIC SAMPLING                   */

BansheeCore/Source/BsRenderWindow.cpp

@@ -24,8 +24,8 @@ namespace BansheeEngine
 		mRequiresTextureFlipping = false;
 	}
 
-	RenderWindowCore::RenderWindowCore(const RENDER_WINDOW_DESC& desc)
-		:mDesc(desc)
+	RenderWindowCore::RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
+		:mDesc(desc), mWindowId(windowId)
 	{
 
 	}
@@ -171,8 +171,8 @@ namespace BansheeEngine
 		RenderTarget::destroy();
 	}
 
-	RenderWindow::RenderWindow(const RENDER_WINDOW_DESC& desc)
-		:mDesc(desc)
+	RenderWindow::RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
+		:mDesc(desc), mWindowId(windowId)
 	{
 
 	}
@@ -353,7 +353,7 @@ namespace BansheeEngine
 	SPtr<CoreObjectCore> RenderWindow::createCore() const
 	{
 		RENDER_WINDOW_DESC desc = mDesc;
-		return RenderWindowCoreManager::instance().createInternal(desc);
+		return RenderWindowCoreManager::instance().createInternal(desc, mWindowId);
 	}
 
 	RenderWindowPtr RenderWindow::create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)

BansheeCore/Source/BsRenderWindowManager.cpp

@@ -18,16 +18,18 @@ namespace BansheeEngine
 
 	RenderWindowPtr RenderWindowManager::create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
-		RenderWindowPtr renderWindow = createImpl(desc, parentWindow);
-		renderWindow->_setThisPtr(renderWindow);
-		renderWindow->initialize();
+		UINT32 id = RenderWindowCoreManager::instance().mNextWindowId.fetch_add(1, std::memory_order_relaxed);
 
+		RenderWindowPtr renderWindow = createImpl(desc, id, parentWindow);
+		renderWindow->_setThisPtr(renderWindow);
+		
 		{
 			BS_LOCK_MUTEX(mWindowMutex);
 
-			mCreatedWindows.push_back(renderWindow.get());
-			mCoreToNonCoreMap[renderWindow->getCore().get()] = renderWindow.get();
+			mWindows[renderWindow->mWindowId] = renderWindow.get();
 		}
+
+		renderWindow->initialize();
 		
 		return renderWindow;
 	}
@@ -37,56 +39,40 @@ namespace BansheeEngine
 		{
 			BS_LOCK_MUTEX(mWindowMutex);
 
-			auto iterFind = std::find(begin(mCreatedWindows), end(mCreatedWindows), window);
-
-			if(iterFind == mCreatedWindows.end())
-				BS_EXCEPT(InternalErrorException, "Trying to destroy a window that is not in the created windows list.");
-
-			mCreatedWindows.erase(iterFind);
-
-			auto iterFind2 = std::find_if(begin(mMovedOrResizedWindows), end(mMovedOrResizedWindows), 
+			auto iterFind = std::find_if(begin(mMovedOrResizedWindows), end(mMovedOrResizedWindows), 
 				[&](const MoveOrResizeData& x) { return x.window == window; });
 
-			if(iterFind2 != mMovedOrResizedWindows.end())
-				mMovedOrResizedWindows.erase(iterFind2);
+			if(iterFind != mMovedOrResizedWindows.end())
+				mMovedOrResizedWindows.erase(iterFind);
 
-			mCoreToNonCoreMap.erase(window->getCore().get());
+			mWindows.erase(window->mWindowId);
 			mDirtyProperties.erase(window);
 		}
 	}
 
 	void RenderWindowManager::notifyFocusReceived(RenderWindowCore* coreWindow)
 	{
-		RenderWindow* window = getNonCore(coreWindow);
-
 		BS_LOCK_MUTEX(mWindowMutex);
+
+		RenderWindow* window = getNonCore(coreWindow);
 		mNewWindowInFocus = window;
 	}
 
 	void RenderWindowManager::notifyFocusLost(RenderWindowCore* coreWindow)
 	{
-		RenderWindow* window = getNonCore(coreWindow);
-
 		BS_LOCK_MUTEX(mWindowMutex);
+
 		mNewWindowInFocus = nullptr;
 	}
 
 	void RenderWindowManager::notifyMovedOrResized(RenderWindowCore* coreWindow)
 	{
-		RenderWindow* window = getNonCore(coreWindow);
-
-		bool isValidWindow = false;
-		{
-			BS_LOCK_MUTEX(mWindowMutex);
-
-			isValidWindow = std::find(begin(mCreatedWindows), end(mCreatedWindows), window) != mCreatedWindows.end();
-		}
+		BS_LOCK_MUTEX(mWindowMutex);
 
-		if(!isValidWindow)
+		RenderWindow* window = getNonCore(coreWindow);
+		if (window == nullptr)
 			return;
 
-		BS_LOCK_MUTEX(mWindowMutex);
-
 		auto iterFind = std::find_if(begin(mMovedOrResizedWindows), end(mMovedOrResizedWindows), 
 			[&](const MoveOrResizeData& x) { return x.window == window; });
 
@@ -96,7 +82,6 @@ namespace BansheeEngine
 		if (iterFind != end(mMovedOrResizedWindows))
 		{
 			moveResizeData = &*iterFind;
-
 		}
 		else
 		{
@@ -118,7 +103,9 @@ namespace BansheeEngine
 		BS_LOCK_MUTEX(mWindowMutex);
 
 		RenderWindow* window = getNonCore(coreWindow);
-		mDirtyProperties.insert(window);
+
+		if (window != nullptr)
+			mDirtyProperties.insert(window);
 	}
 
 	void RenderWindowManager::windowMouseLeft(RenderWindowCore* coreWindow)
@@ -195,22 +182,33 @@ namespace BansheeEngine
 	{
 		BS_LOCK_MUTEX(mWindowMutex);
 
-		return mCreatedWindows;
+		Vector<RenderWindow*> windows;
+		for (auto& windowPair : mWindows)
+			windows.push_back(windowPair.second);
+
+		return windows;
 	}
 
 	RenderWindow* RenderWindowManager::getNonCore(const RenderWindowCore* window) const
 	{
-		auto iterFind = mCoreToNonCoreMap.find(window);
+		auto iterFind = mWindows.find(window->mWindowId);
 
-		if (iterFind != mCoreToNonCoreMap.end())
+		if (iterFind != mWindows.end())
 			return iterFind->second;
 
 		return nullptr;
 	}
 
+	RenderWindowCoreManager::RenderWindowCoreManager()
+	{
+		mNextWindowId = 0;
+	}
+
 	SPtr<RenderWindowCore> RenderWindowCoreManager::create(RENDER_WINDOW_DESC& desc)
 	{
-		SPtr<RenderWindowCore> renderWindow = createInternal(desc);
+		UINT32 id = mNextWindowId.fetch_add(1, std::memory_order_relaxed);
+
+		SPtr<RenderWindowCore> renderWindow = createInternal(desc, id);
 		renderWindow->initialize();
 
 		return renderWindow;

BansheeD3D11RenderSystem/Include/BsD3D11RenderWindow.h

@@ -32,7 +32,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	RenderWindowCore::RenderWindowCore
 		 */
-		D3D11RenderWindowCore(const RENDER_WINDOW_DESC& desc,
+		D3D11RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId,
 			D3D11Device& device, IDXGIFactory* DXGIFactory);
 
 		~D3D11RenderWindowCore();
@@ -223,7 +223,8 @@ namespace BansheeEngine
 		friend class D3D11RenderWindowManager;
 		friend class D3D11RenderWindowCore;
 
-		D3D11RenderWindow(const RENDER_WINDOW_DESC& desc, D3D11Device& device, IDXGIFactory* DXGIFactory);
+		D3D11RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, 
+			D3D11Device& device, IDXGIFactory* DXGIFactory);
 
 		/**
 		 * @copydoc	RenderWindowCore::getProperties

BansheeD3D11RenderSystem/Include/BsD3D11RenderWindowManager.h

@@ -17,7 +17,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc RenderWindowManager::createImpl
 		 */
-		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow);
+		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow);
 
 	private:
 		D3D11RenderAPI* mRenderSystem;
@@ -35,7 +35,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc RenderWindowCoreManager::createInternal
 		 */
-		virtual SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc);
+		virtual SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId);
 
 	private:
 		D3D11RenderAPI* mRenderSystem;

BansheeD3D11RenderSystem/Source/BsD3D11RenderWindow.cpp

@@ -20,8 +20,8 @@ namespace BansheeEngine
 		:RenderWindowProperties(desc)
 	{ }
 
-	D3D11RenderWindowCore::D3D11RenderWindowCore(const RENDER_WINDOW_DESC& desc, D3D11Device& device, IDXGIFactory* DXGIFactory)
-		: RenderWindowCore(desc), mProperties(desc), mSyncedProperties(desc), mDevice(device), mDXGIFactory(DXGIFactory), mIsExternal(false), 
+	D3D11RenderWindowCore::D3D11RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, D3D11Device& device, IDXGIFactory* DXGIFactory)
+		: RenderWindowCore(desc, windowId), mProperties(desc), mSyncedProperties(desc), mDevice(device), mDXGIFactory(DXGIFactory), mIsExternal(false), 
 		mSizing(false), mRenderTargetView(nullptr), mBackBuffer(nullptr), mSwapChain(nullptr), mDepthStencilView(nullptr), mIsChild(false), 
 		 mRefreshRateNumerator(0), mRefreshRateDenominator(0), mHWnd(0)
 	{ }
@@ -815,8 +815,8 @@ namespace BansheeEngine
 		mProperties = mSyncedProperties;
 	}
 
-	D3D11RenderWindow::D3D11RenderWindow(const RENDER_WINDOW_DESC& desc, D3D11Device& device, IDXGIFactory* DXGIFactory)
-		:RenderWindow(desc), mProperties(desc), mDevice(device), mDXGIFactory(DXGIFactory)
+	D3D11RenderWindow::D3D11RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, D3D11Device& device, IDXGIFactory* DXGIFactory)
+		:RenderWindow(desc, windowId), mProperties(desc), mDevice(device), mDXGIFactory(DXGIFactory)
 	{
 
 	}

BansheeD3D11RenderSystem/Source/BsD3D11RenderWindowManager.cpp

@@ -11,7 +11,7 @@ namespace BansheeEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	RenderWindowPtr D3D11RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow)
+	RenderWindowPtr D3D11RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow)
 	{
 		RenderAPICore* rs = RenderAPICore::instancePtr();
 		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(rs);
@@ -24,7 +24,7 @@ namespace BansheeEngine
 		}
 
 		// Create the window
-		D3D11RenderWindow* renderWindow = new (bs_alloc<D3D11RenderWindow, PoolAlloc>()) D3D11RenderWindow(desc, d3d11rs->getPrimaryDevice(), d3d11rs->getDXGIFactory());
+		D3D11RenderWindow* renderWindow = new (bs_alloc<D3D11RenderWindow, PoolAlloc>()) D3D11RenderWindow(desc, windowId, d3d11rs->getPrimaryDevice(), d3d11rs->getDXGIFactory());
 		return bs_core_ptr<D3D11RenderWindow, PoolAlloc>(renderWindow);
 	}
 
@@ -34,13 +34,13 @@ namespace BansheeEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	SPtr<RenderWindowCore> D3D11RenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc)
+	SPtr<RenderWindowCore> D3D11RenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
 	{
 		RenderAPICore* rs = RenderAPICore::instancePtr();
 		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(rs);
 
 		// Create the window
-		D3D11RenderWindowCore* renderWindow = new (bs_alloc<D3D11RenderWindowCore, GenAlloc>()) D3D11RenderWindowCore(desc, d3d11rs->getPrimaryDevice(), d3d11rs->getDXGIFactory());
+		D3D11RenderWindowCore* renderWindow = new (bs_alloc<D3D11RenderWindowCore, GenAlloc>()) D3D11RenderWindowCore(desc, windowId, d3d11rs->getPrimaryDevice(), d3d11rs->getDXGIFactory());
 
 		SPtr<D3D11RenderWindowCore> renderWindowPtr = bs_shared_ptr<D3D11RenderWindowCore, GenAlloc>(renderWindow);
 		renderWindowPtr->_setThisPtr(renderWindowPtr);

BansheeD3D9RenderSystem/Include/BsD3D9RenderWindow.h

@@ -30,7 +30,7 @@ namespace BansheeEngine
 	class BS_D3D9_EXPORT D3D9RenderWindowCore : public RenderWindowCore
 	{
 	public:
-		D3D9RenderWindowCore(const RENDER_WINDOW_DESC& desc, HINSTANCE instance);
+		D3D9RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, HINSTANCE instance);
 		~D3D9RenderWindowCore();
 		
 		/**
@@ -226,7 +226,7 @@ namespace BansheeEngine
 		friend class D3D9RenderWindowManager;
 		friend class D3D9RenderWindowCore;
 
-		D3D9RenderWindow(const RENDER_WINDOW_DESC& desc, HINSTANCE instance);
+		D3D9RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, HINSTANCE instance);
 
 		/**
 		 * @copydoc	RenderWindowCore::getProperties

BansheeD3D9RenderSystem/Include/BsD3D9RenderWindowManager.h

@@ -17,7 +17,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc RenderWindowManager::createImpl()
 		 */
-		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow);
+		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow);
 
 	private:
 		D3D9RenderAPI* mRenderSystem;
@@ -35,7 +35,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc RenderWindowCoreManager::createInternal
 		 */
-		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc);
+		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId);
 
 	private:
 		D3D9RenderAPI* mRenderSystem;

BansheeD3D9RenderSystem/Source/BsD3D9RenderWindow.cpp

@@ -19,8 +19,8 @@ namespace BansheeEngine
 
 	}
 
-	D3D9RenderWindowCore::D3D9RenderWindowCore(const RENDER_WINDOW_DESC& desc, HINSTANCE instance)
-		: RenderWindowCore(desc), mInstance(instance), mProperties(desc), mSyncedProperties(desc), mIsDepthBuffered(true), mIsChild(false), mHWnd(0),
+	D3D9RenderWindowCore::D3D9RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, HINSTANCE instance)
+		: RenderWindowCore(desc, windowId), mInstance(instance), mProperties(desc), mSyncedProperties(desc), mIsDepthBuffered(true), mIsChild(false), mHWnd(0),
 		mStyle(0), mWindowedStyle(0), mWindowedStyleEx(0), mDevice(nullptr), mIsExternal(false), mDisplayFrequency(0), mDeviceValid(false)
 	{ }
 
@@ -738,8 +738,8 @@ namespace BansheeEngine
 		mProperties = mSyncedProperties;
 	}
 
-	D3D9RenderWindow::D3D9RenderWindow(const RENDER_WINDOW_DESC& desc, HINSTANCE instance)
-		:RenderWindow(desc), mInstance(instance), mProperties(desc)
+	D3D9RenderWindow::D3D9RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, HINSTANCE instance)
+		:RenderWindow(desc, windowId), mInstance(instance), mProperties(desc)
 	{
 
 	}

BansheeD3D9RenderSystem/Source/BsD3D9RenderWindowManager.cpp

@@ -11,7 +11,7 @@ namespace BansheeEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	RenderWindowPtr D3D9RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow)
+	RenderWindowPtr D3D9RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow)
 	{
 		if(parentWindow != nullptr)
 		{
@@ -20,7 +20,7 @@ namespace BansheeEngine
 			desc.platformSpecific["parentWindowHandle"] = toString(hWnd);
 		}
 
-		D3D9RenderWindow* window = new (bs_alloc<D3D9RenderWindow, PoolAlloc>()) D3D9RenderWindow(desc, mRenderSystem->getInstanceHandle());
+		D3D9RenderWindow* window = new (bs_alloc<D3D9RenderWindow, PoolAlloc>()) D3D9RenderWindow(desc, windowId, mRenderSystem->getInstanceHandle());
 
 		return RenderWindowPtr(window, &CoreObject::_delete<D3D9RenderWindow, PoolAlloc>);
 	}
@@ -31,9 +31,9 @@ namespace BansheeEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	SPtr<RenderWindowCore> D3D9RenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc)
+	SPtr<RenderWindowCore> D3D9RenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
 	{
-		D3D9RenderWindowCore* window = new (bs_alloc<D3D9RenderWindowCore, GenAlloc>()) D3D9RenderWindowCore(desc, mRenderSystem->getInstanceHandle());
+		D3D9RenderWindowCore* window = new (bs_alloc<D3D9RenderWindowCore, GenAlloc>()) D3D9RenderWindowCore(desc, windowId, mRenderSystem->getInstanceHandle());
 
 		SPtr<D3D9RenderWindowCore> renderWindowPtr = bs_shared_ptr<D3D9RenderWindowCore, GenAlloc>(window);
 		renderWindowPtr->_setThisPtr(renderWindowPtr);

BansheeEditor/Source/BsEditorApplication.cpp

@@ -182,14 +182,14 @@ namespace BansheeEngine
 
 		mTestMaterial = Material::create(mTestShader);
 
-		mTestTexRef = static_resource_cast<Texture>(Importer::instance().import(L"..\\..\\..\\..\\Data\\Examples\\Dragon.tga"));
-		mDbgMeshRef = static_resource_cast<Mesh>(Importer::instance().import(L"..\\..\\..\\..\\Data\\Examples\\Dragon.fbx"));
+		//mTestTexRef = static_resource_cast<Texture>(Importer::instance().import(L"..\\..\\..\\..\\Data\\Examples\\Dragon.tga"));
+		//mDbgMeshRef = static_resource_cast<Mesh>(Importer::instance().import(L"..\\..\\..\\..\\Data\\Examples\\Dragon.fbx"));
 
-		gResources().save(mTestTexRef, L"C:\\ExportTest.tex", true);
-		gResources().save(mDbgMeshRef, L"C:\\ExportMesh.mesh", true);
+		//gResources().save(mTestTexRef, L"C:\\ExportTest.tex", true);
+		//gResources().save(mDbgMeshRef, L"C:\\ExportMesh.mesh", true);
 
-		gResources().unload(mTestTexRef);
-		gResources().unload(mDbgMeshRef);
+		//gResources().unload(mTestTexRef);
+		//gResources().unload(mDbgMeshRef);
 
 		mTestTexRef = static_resource_cast<Texture>(gResources().loadAsync(L"C:\\ExportTest.tex"));
 		mDbgMeshRef = static_resource_cast<Mesh>(gResources().loadAsync(L"C:\\ExportMesh.mesh"));

BansheeGLRenderSystem/Include/BsGLRenderWindowManager.h

@@ -17,7 +17,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc RenderWindowManager::createImpl()
 		 */
-		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow);
+		RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow);
 
 	private:
 		GLRenderAPI* mRenderSystem;
@@ -35,7 +35,7 @@ namespace BansheeEngine
 		/**
 		 * @copydoc RenderWindowCoreManager::createInternal
 		 */
-		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc);
+		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId);
 
 	private:
 		GLRenderAPI* mRenderSystem;

BansheeGLRenderSystem/Include/BsGLSupport.h

@@ -20,23 +20,25 @@ namespace BansheeEngine
 		 * @brief	Creates a new render window using the specified descriptor.
 		 *
 		 * @param	desc			Description of a render window to create.
+		 * @param	windowId		Window ID provided by the render window manager.
 		 * @param	parentWindow	Optional parent window if the window shouldn't be a main window. First
 		 *							created window cannot have a parent.
 		 *
 		 * @param	Returns newly created window.
 		 */
-		virtual RenderWindowPtr newWindow(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow) = 0;
+		virtual RenderWindowPtr newWindow(RENDER_WINDOW_DESC& desc, UINT32 windowId, RenderWindowPtr parentWindow) = 0;
 
 		/**
 		 * @brief	Creates a new render window using the specified descriptor.
 		 *
 		 * @param	desc			Description of a render window to create.
+		 * @param	windowId		Window ID provided by the render window manager.
 		 * @param	parentWindow	Optional parent window if the window shouldn't be a main window. First
 		 *							created window cannot have a parent.
 		 *
 		 * @param	Returns newly created window.
 		 */
-		virtual SPtr<RenderWindowCore> newWindowCore(RENDER_WINDOW_DESC& desc) = 0;
+		virtual SPtr<RenderWindowCore> newWindowCore(RENDER_WINDOW_DESC& desc, UINT32 windowId) = 0;
 
 		/**
 		 * @brief	Called when OpenGL is being initialized.

BansheeGLRenderSystem/Include/BsWin32GLSupport.h

@@ -18,12 +18,12 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	GLSupport::newWindow
 		 */
-		virtual RenderWindowPtr newWindow(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
+		virtual RenderWindowPtr newWindow(RENDER_WINDOW_DESC& desc, UINT32 windowId, RenderWindowPtr parentWindow);
 
 		/**
 		 * @copydoc	GLSupport::newWindowCore
 		 */
-		virtual SPtr<RenderWindowCore> newWindowCore(RENDER_WINDOW_DESC& desc);
+		virtual SPtr<RenderWindowCore> newWindowCore(RENDER_WINDOW_DESC& desc, UINT32 windowId);
 
 		/**
 		 * @copydoc	GLSupport::start

BansheeGLRenderSystem/Include/BsWin32Window.h

@@ -29,7 +29,7 @@ namespace BansheeEngine
     class BS_RSGL_EXPORT Win32WindowCore : public RenderWindowCore
     {
     public:
-		Win32WindowCore(const RENDER_WINDOW_DESC& desc, Win32GLSupport &glsupport);
+		Win32WindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, Win32GLSupport &glsupport);
 		~Win32WindowCore();
 
 		/**
@@ -193,7 +193,7 @@ namespace BansheeEngine
 		friend class Win32GLSupport;
 		friend class Win32WindowCore;
 
-		Win32Window(const RENDER_WINDOW_DESC& desc, Win32GLSupport& glsupport);
+		Win32Window(const RENDER_WINDOW_DESC& desc, UINT32 windowId, Win32GLSupport& glsupport);
 
 		/**
 		 * @copydoc	RenderWindow::getProperties

BansheeGLRenderSystem/Source/BsGLRenderWindowManager.cpp

@@ -11,12 +11,12 @@ namespace BansheeEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	RenderWindowPtr GLRenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, const RenderWindowPtr& parentWindow)
+	RenderWindowPtr GLRenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const RenderWindowPtr& parentWindow)
 	{
 		GLSupport* glSupport = mRenderSystem->getGLSupport();
 
 		// Create the window
-		return glSupport->newWindow(desc, parentWindow);
+		return glSupport->newWindow(desc, windowId, parentWindow);
 	}
 
 	GLRenderWindowCoreManager::GLRenderWindowCoreManager(GLRenderAPI* renderSystem)
@@ -25,12 +25,12 @@ namespace BansheeEngine
 		assert(mRenderSystem != nullptr);
 	}
 
-	SPtr<RenderWindowCore> GLRenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc)
+	SPtr<RenderWindowCore> GLRenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
 	{
 		GLSupport* glSupport = mRenderSystem->getGLSupport();
 
 		// Create the window
-		SPtr<RenderWindowCore> window = glSupport->newWindowCore(desc);
+		SPtr<RenderWindowCore> window = glSupport->newWindowCore(desc, windowId);
 		window->_setThisPtr(window);
 
 		windowCreated(window.get());

BansheeGLRenderSystem/Source/BsWin32GLSupport.cpp

@@ -26,7 +26,7 @@ namespace BansheeEngine
 		initialiseWGL();
     } 
 
-	RenderWindowPtr Win32GLSupport::newWindow(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
+	RenderWindowPtr Win32GLSupport::newWindow(RENDER_WINDOW_DESC& desc, UINT32 windowId, RenderWindowPtr parentWindow)
 	{		
 		if(parentWindow != nullptr)
 		{
@@ -35,13 +35,13 @@ namespace BansheeEngine
 			desc.platformSpecific["parentWindowHandle"] = toString(hWnd);
 		}
 
-		Win32Window* window = new (bs_alloc<Win32Window, PoolAlloc>()) Win32Window(desc, *this);
+		Win32Window* window = new (bs_alloc<Win32Window, PoolAlloc>()) Win32Window(desc, windowId, *this);
 		return RenderWindowPtr(window, &CoreObject::_delete<Win32Window, PoolAlloc>);
 	}
 
-	SPtr<RenderWindowCore> Win32GLSupport::newWindowCore(RENDER_WINDOW_DESC& desc)
+	SPtr<RenderWindowCore> Win32GLSupport::newWindowCore(RENDER_WINDOW_DESC& desc, UINT32 windowId)
 	{
-		Win32WindowCore* window = new (bs_alloc<Win32WindowCore, GenAlloc>()) Win32WindowCore(desc, *this);
+		Win32WindowCore* window = new (bs_alloc<Win32WindowCore, GenAlloc>()) Win32WindowCore(desc, windowId, *this);
 
 		if (!mInitialWindow)
 			mInitialWindow = window;

BansheeGLRenderSystem/Source/BsWin32Window.cpp

@@ -24,8 +24,8 @@ namespace BansheeEngine
 		:RenderWindowProperties(desc)
 	{ }
 
-	Win32WindowCore::Win32WindowCore(const RENDER_WINDOW_DESC& desc, Win32GLSupport& glsupport)
-		: RenderWindowCore(desc), mProperties(desc), mSyncedProperties(desc), mGLSupport(glsupport), mContext(0), 
+	Win32WindowCore::Win32WindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, Win32GLSupport& glsupport)
+		: RenderWindowCore(desc, windowId), mProperties(desc), mSyncedProperties(desc), mGLSupport(glsupport), mContext(0), 
 		mWindowedStyle(0), mWindowedStyleEx(0), mIsExternal(false), mIsExternalGLControl(false), mDisplayFrequency(0), mDeviceName(nullptr), mHWnd(0)
 	{ }
 
@@ -753,8 +753,8 @@ namespace BansheeEngine
 		mProperties = mSyncedProperties;
 	}
 
-	Win32Window::Win32Window(const RENDER_WINDOW_DESC& desc, Win32GLSupport &glsupport)
-		:RenderWindow(desc), mGLSupport(glsupport), mProperties(desc)
+	Win32Window::Win32Window(const RENDER_WINDOW_DESC& desc, UINT32 windowId, Win32GLSupport &glsupport)
+		:RenderWindow(desc, windowId), mGLSupport(glsupport), mProperties(desc)
 	{
 
 	}