Moved methods for manipulating render target from sim thread from core accessor to RenderTarget/RenderWindow

BansheeCore/Include/BsCoreThreadAccessor.h

@@ -126,46 +126,6 @@ namespace BansheeEngine
 		 */
 		AsyncOp readSubresource(GpuResourcePtr resource, UINT32 subresourceIdx, const GpuResourceDataPtr& data);
 
-		/**
-		 * @brief	Resize the provided window to specified width and height in pixels.
-		 */
-		void resizeWindow(const RenderWindowPtr& renderWindow, UINT32 width, UINT32 height);
-
-		/**
-		 * @brief	Move the provided window to specified screen coordinates.
-		 */
-		void moveWindow(const RenderWindowPtr& renderWindow, INT32 left, INT32 top);
-
-		/**
-		 * @brief	Hide the provided window. (Does not destroy it, just hides it).
-		 */
-		void hideWindow(const RenderWindowPtr& renderWindow);
-
-		/**
-		 * @brief	Shows a previously hidden window.
-		 */
-		void showWindow(const RenderWindowPtr& renderWindow);
-
-		/**
-		 * @copydoc RenderWindow::setFullscreen(UINT32, UINT32, float, UINT32)
-		 */
-		void setFullscreen(const RenderWindowPtr& renderWindow, UINT32 width, UINT32 height, float refreshRate = 60.0f, UINT32 monitorIdx = 0);
-
-		/**
-		 * @copydoc RenderWindow::setFullscreen(const VideoMode&)
-		 */
-		void setFullscreen(const RenderWindowPtr& renderWindow, const VideoMode& mode);
-
-		/**
-		 * @copydoc RenderWindow::setWindowed
-		 */
-		void setWindowed(const RenderWindowPtr& renderWindow, UINT32 width, UINT32 height);
-
-		/**
-		 * @copydoc RenderTargetcore::setPriority
-		 */
-		void setPriority(const RenderTargetPtr& renderTarget, UINT32 priority);
-
 		/**
 		* @brief	Queues a new generic command that will be added to the command queue.
 		*/

BansheeCore/Include/BsRenderTarget.h

@@ -188,6 +188,11 @@ namespace BansheeEngine
 		 */
 		virtual void getCustomAttribute(const String& name, void* pData) const;
 
+		/**
+		 * @copydoc RenderTargetCore::setPriority
+		 */
+		void setPriority(CoreAccessor& accessor, UINT32 priority);
+
 		/**
 		 * @brief	Returns properties that describe the render target.
 		 *

BansheeCore/Include/BsRenderWindow.h

@@ -231,6 +231,41 @@ namespace BansheeEngine
 		 */
 		virtual Vector2I windowToScreenPos(const Vector2I& windowPos) const = 0;
 
+		/**
+		 * @brief	Resize the window to specified width and height in pixels.
+		 */
+		void resize(CoreAccessor& accessor, UINT32 width, UINT32 height);
+
+		/**
+		 * @brief	Move the window to specified screen coordinates.
+		 */
+		void move(CoreAccessor& accessor, INT32 left, INT32 top);
+
+		/**
+		 * @brief	Hide the window. (Does not destroy it, just hides it).
+		 */
+		void hide(CoreAccessor& accessor);
+
+		/**
+		 * @brief	Shows a previously hidden window.
+		 */
+		void show(CoreAccessor& accessor);
+
+		/**
+		 * @copydoc RenderWindowCore::setFullscreen(UINT32, UINT32, float, UINT32)
+		 */
+		void setFullscreen(CoreAccessor& accessor, UINT32 width, UINT32 height, float refreshRate = 60.0f, UINT32 monitorIdx = 0);
+
+		/**
+		 * @copydoc RenderWindowCore::setFullscreen(const VideoMode&)
+		 */
+		void setFullscreen(CoreAccessor& accessor, const VideoMode& mode);
+
+		/**
+		 * @copydoc RenderWindowCore::setWindowed
+		 */
+		void setWindowed(CoreAccessor& accessor, UINT32 width, UINT32 height);
+
 		/**
 		 * @brief	Retrieves a core implementation of a render window usable only from the
 		 *			core thread.

BansheeCore/Source/BsCoreThreadAccessor.cpp

@@ -190,95 +190,6 @@ namespace BansheeEngine
 			resource, subresourceIdx, data, std::placeholders::_1));
 	}
 
-	void CoreThreadAccessorBase::resizeWindow(const RenderWindowPtr& renderWindow, UINT32 width, UINT32 height)
-	{
-		std::function<void(RenderWindowPtr, UINT32, UINT32)> resizeFunc = 
-			[](RenderWindowPtr renderWindow, UINT32 width, UINT32 height)
-		{
-			renderWindow->getCore()->resize(width, height);
-		};
-
-		mCommandQueue->queue(std::bind(resizeFunc, renderWindow, width, height));
-	}
-
-	void CoreThreadAccessorBase::moveWindow(const RenderWindowPtr& renderWindow, INT32 left, INT32 top)
-	{
-		std::function<void(RenderWindowPtr, INT32, INT32)> moveFunc =
-			[](RenderWindowPtr renderWindow, INT32 left, INT32 top)
-		{
-			renderWindow->getCore()->move(left, top);
-		};
-
-		mCommandQueue->queue(std::bind(moveFunc, renderWindow, left, top));
-	}
-
-	void CoreThreadAccessorBase::hideWindow(const RenderWindowPtr& renderWindow)
-	{
-		std::function<void(RenderWindowPtr)> hideFunc =
-			[](RenderWindowPtr renderWindow)
-		{
-			renderWindow->getCore()->setHidden(true);
-		};
-
-		mCommandQueue->queue(std::bind(hideFunc, renderWindow));
-	}
-
-	void CoreThreadAccessorBase::showWindow(const RenderWindowPtr& renderWindow)
-	{
-		std::function<void(RenderWindowPtr)> showFunc =
-			[](RenderWindowPtr renderWindow)
-		{
-			renderWindow->getCore()->setHidden(false);
-		};
-
-		mCommandQueue->queue(std::bind(showFunc, renderWindow));
-	}
-
-	void CoreThreadAccessorBase::setFullscreen(const RenderWindowPtr& renderWindow, UINT32 width, UINT32 height,
-		float refreshRate, UINT32 monitorIdx)
-	{
-		std::function<void(RenderWindowPtr, UINT32, UINT32, float, UINT32)> fullscreenFunc =
-			[](RenderWindowPtr renderWindow, UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
-		{
-			renderWindow->getCore()->setFullscreen(width, height, refreshRate, monitorIdx);
-		};
-
-		mCommandQueue->queue(std::bind(fullscreenFunc, renderWindow, width, height, refreshRate, monitorIdx));
-	}
-
-	void CoreThreadAccessorBase::setFullscreen(const RenderWindowPtr& renderWindow, const VideoMode& mode)
-	{
-		std::function<void(RenderWindowPtr, const VideoMode&)> fullscreenFunc =
-			[](RenderWindowPtr renderWindow, const VideoMode& mode)
-		{
-			renderWindow->getCore()->setFullscreen(mode);
-		};
-
-		mCommandQueue->queue(std::bind(fullscreenFunc, renderWindow, std::cref(mode)));
-	}
-
-	void CoreThreadAccessorBase::setWindowed(const RenderWindowPtr& renderWindow, UINT32 width, UINT32 height)
-	{
-		std::function<void(RenderWindowPtr, UINT32, UINT32)> windowedFunc =
-			[](RenderWindowPtr renderWindow, UINT32 width, UINT32 height)
-		{
-			renderWindow->getCore()->setWindowed(width, height);
-		};
-
-		mCommandQueue->queue(std::bind(windowedFunc, renderWindow, width, height));
-	}
-
-	void CoreThreadAccessorBase::setPriority(const RenderTargetPtr& renderTarget, UINT32 priority)
-	{
-		std::function<void(RenderTargetPtr, UINT32)> windowedFunc =
-			[](RenderTargetPtr renderTarget, UINT32 priority)
-		{
-			renderTarget->getCore()->setPriority(priority);
-		};
-
-		mCommandQueue->queue(std::bind(windowedFunc, renderTarget, priority));
-	}
-
 	AsyncOp CoreThreadAccessorBase::queueReturnCommand(std::function<void(AsyncOp&)> commandCallback)
 	{
 		return mCommandQueue->queueReturn(commandCallback);

BansheeCore/Source/BsRenderTarget.cpp

@@ -38,6 +38,17 @@ namespace BansheeEngine
 		BS_EXCEPT(InvalidParametersException, "Attribute not found.");
 	}
 
+	void RenderTarget::setPriority(CoreAccessor& accessor, UINT32 priority)
+	{
+		std::function<void(SPtr<RenderTargetCore>, UINT32)> windowedFunc =
+			[](SPtr<RenderTargetCore> renderTarget, UINT32 priority)
+		{
+			renderTarget->setPriority(priority);
+		};
+
+		accessor.queueCommand(std::bind(windowedFunc, getCore(), priority));
+	}
+
 	SPtr<RenderTargetCore> RenderTarget::getCore() const
 	{
 		return std::static_pointer_cast<RenderTargetCore>(mCoreSpecific);

BansheeCore/Source/BsRenderWindow.cpp

@@ -104,6 +104,84 @@ namespace BansheeEngine
 
 	}
 
+	void RenderWindow::resize(CoreAccessor& accessor, UINT32 width, UINT32 height)
+	{
+		std::function<void(SPtr<RenderWindowCore>, UINT32, UINT32)> resizeFunc =
+			[](SPtr<RenderWindowCore> renderWindow, UINT32 width, UINT32 height)
+		{
+			renderWindow->resize(width, height);
+		};
+
+		accessor.queueCommand(std::bind(resizeFunc, getCore(), width, height));
+	}
+
+	void RenderWindow::move(CoreAccessor& accessor, INT32 left, INT32 top)
+	{
+		std::function<void(SPtr<RenderWindowCore>, INT32, INT32)> moveFunc =
+			[](SPtr<RenderWindowCore> renderWindow, INT32 left, INT32 top)
+		{
+			renderWindow->move(left, top);
+		};
+
+		accessor.queueCommand(std::bind(moveFunc, getCore(), left, top));
+	}
+
+	void RenderWindow::hide(CoreAccessor& accessor)
+	{
+		std::function<void(SPtr<RenderWindowCore>)> hideFunc =
+			[](SPtr<RenderWindowCore> renderWindow)
+		{
+			renderWindow->setHidden(true);
+		};
+
+		accessor.queueCommand(std::bind(hideFunc, getCore()));
+	}
+
+	void RenderWindow::show(CoreAccessor& accessor)
+	{
+		std::function<void(SPtr<RenderWindowCore>)> showFunc =
+			[](SPtr<RenderWindowCore> renderWindow)
+		{
+			renderWindow->setHidden(false);
+		};
+
+		accessor.queueCommand(std::bind(showFunc, getCore()));
+	}
+
+	void RenderWindow::setFullscreen(CoreAccessor& accessor, UINT32 width, UINT32 height,
+		float refreshRate, UINT32 monitorIdx)
+	{
+		std::function<void(SPtr<RenderWindowCore>, UINT32, UINT32, float, UINT32)> fullscreenFunc =
+			[](SPtr<RenderWindowCore> renderWindow, UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
+		{
+			renderWindow->setFullscreen(width, height, refreshRate, monitorIdx);
+		};
+
+		accessor.queueCommand(std::bind(fullscreenFunc, getCore(), width, height, refreshRate, monitorIdx));
+	}
+
+	void RenderWindow::setFullscreen(CoreAccessor& accessor, const VideoMode& mode)
+	{
+		std::function<void(SPtr<RenderWindowCore>, const VideoMode&)> fullscreenFunc =
+			[](SPtr<RenderWindowCore> renderWindow, const VideoMode& mode)
+		{
+			renderWindow->setFullscreen(mode);
+		};
+
+		accessor.queueCommand(std::bind(fullscreenFunc, getCore(), std::cref(mode)));
+	}
+
+	void RenderWindow::setWindowed(CoreAccessor& accessor, UINT32 width, UINT32 height)
+	{
+		std::function<void(SPtr<RenderWindowCore>, UINT32, UINT32)> windowedFunc =
+			[](SPtr<RenderWindowCore> renderWindow, UINT32 width, UINT32 height)
+		{
+			renderWindow->setWindowed(width, height);
+		};
+
+		accessor.queueCommand(std::bind(windowedFunc, getCore(), width, height));
+	}
+
 	SPtr<RenderWindowCore> RenderWindow::getCore() const
 	{
 		return std::static_pointer_cast<RenderWindowCore>(mCoreSpecific);

BansheeEditor/Source/BsEditorWindowBase.cpp

@@ -55,7 +55,7 @@ namespace BansheeEngine
 
 	void EditorWindowBase::hide()
 	{
-		gCoreAccessor().hideWindow(mRenderWindow);
+		mRenderWindow->hide(gCoreAccessor());
 	}
 
 	void EditorWindowBase::construct(const RenderWindowPtr& renderWindow)
@@ -81,12 +81,12 @@ namespace BansheeEngine
 
 	void EditorWindowBase::setPosition(INT32 x, INT32 y)
 	{
-		gCoreAccessor().moveWindow(mRenderWindow, x, y);
+		mRenderWindow->move(gCoreAccessor(), x, y);
 	}
 
 	void EditorWindowBase::setSize(UINT32 width, UINT32 height)
 	{
-		gCoreAccessor().resizeWindow(mRenderWindow, width, height);
+		mRenderWindow->resize(gCoreAccessor(), width, height);
 	}
 
 	INT32 EditorWindowBase::getLeft() const

BansheeEditor/Source/BsSceneEditorWidget.cpp

@@ -255,7 +255,7 @@ namespace BansheeEngine
 			mSceneRenderTarget->destroy();
 
 		mSceneRenderTarget = RenderTexture::create(TEX_TYPE_2D, width, height);
-		gCoreAccessor().setPriority(mSceneRenderTarget, 1);
+		mSceneRenderTarget->setPriority(gCoreAccessor(), 1);
 
 		if (mCamera == nullptr)
 		{

BansheeEditor/Source/DbgEditorWidget2.cpp

@@ -28,14 +28,14 @@ namespace BansheeEngine
 
 	void toggleFullscreen()
 	{
+		RenderWindowPtr window = gCoreApplication().getPrimaryWindow();
 		if (bs_dbg_fullscreen)
 		{
-			gCoreAccessor().setWindowed(gCoreApplication().getPrimaryWindow(), 1280, 720);
+			window->setWindowed(gCoreAccessor(), 1280, 720);
 		}
 		else
 		{
-			//gCoreAccessor().setFullscreen(window, *videoMode);
-			gCoreAccessor().setFullscreen(gCoreApplication().getPrimaryWindow(), 1920, 1200, 60, 0);
+			window->setFullscreen(gCoreAccessor(), 1920, 1200, 60, 0);
 		}
 
 		bs_dbg_fullscreen = !bs_dbg_fullscreen;

ExampleProject/Main/Main.cpp

@@ -498,11 +498,11 @@ namespace BansheeEngine
 		// call something from the wrong thread.
 		if (fullscreen)
 		{
-			gCoreAccessor().setWindowed(window, windowResWidth, windowResHeight);
+			window->setWindowed(gCoreAccessor(), windowResWidth, windowResHeight);
 		}
 		else
 		{
-			gCoreAccessor().setFullscreen(window, *selectedVideoMode);
+			window->setFullscreen(gCoreAccessor(), *selectedVideoMode);
 		}
 
 		fullscreen = !fullscreen;
@@ -511,14 +511,15 @@ namespace BansheeEngine
 	void renderWindowResized()
 	{
 		RenderWindowPtr window = gApplication().getPrimaryWindow();
+		const RenderWindowProperties& rwProps = window->getProperties();
 
 		if (!fullscreen)
 		{
-			windowResWidth = window->getWidth();
-			windowResHeight = window->getHeight();
+			windowResWidth = rwProps.getWidth();
+			windowResHeight = rwProps.getHeight();
 		}
 
-		sceneCamera->setAspectRatio(window->getWidth() / (float)window->getHeight());
+		sceneCamera->setAspectRatio(rwProps.getWidth() / (float)rwProps.getHeight());
 	}
 
 	void videoModeChanged(UINT32 idx)
@@ -528,7 +529,7 @@ namespace BansheeEngine
 		if (fullscreen)
 		{
 			RenderWindowPtr window = gApplication().getPrimaryWindow();
-			gCoreAccessor().setFullscreen(window, *selectedVideoMode);
+			window->setFullscreen(gCoreAccessor(), *selectedVideoMode);
 		}
 	}
 

TODO.txt

@@ -25,10 +25,6 @@ Disallow CoreObject creation from core thread
  - Add asserts in CoreObject::destroy and CoreObject::initialize
  - Possibly also add asserts to CoreThread::queueCommand and CoreThread::queueReturnCommand
 
-RENDER TARGET REFACTOR:
-Need RenderWindow::create that works from core thread used for creating the primary window
- - RenderSystem then needs to wrap the returned RenderWindowCore into a proper RenderWindow for use by the sim thread
-
 Move CoreAccessor methods relating to render target, to the render targets themselves
 
 -----------------