Fixed order of updates:

 - Virtual input gets update before components
 - Renderable/Camera transform updates now happen after component updates, and after editor handle updates

BansheeCore/Include/BsCoreSceneManager.h

@@ -30,12 +30,19 @@ namespace BansheeEngine
 		void clearScene(bool forceAll = false);
 
 		/**
-		 * @brief	Called every frame.
+		 * @brief	Called every frame. Calls update methods on all 
+		 *			scene objects and their components.
 		 *
 		 * @note	Internal method.
 		 */
 		virtual void _update();
 
+		/**
+		 * @brief	Updates dirty transforms on any core objects that may be tied with
+		 *			scene objects.
+		 */
+		virtual void _updateCoreObjectTransforms() { }
+
 	protected:
 		friend class SceneObject;
 

BansheeCore/Source/BsCoreApplication.cpp

@@ -206,6 +206,7 @@ namespace BansheeEngine
 			// Send out resource events in case any were loaded/destroyed/modified
 			ResourceListenerManager::instance().update();
 
+			gCoreSceneManager()._updateCoreObjectTransforms();
 			PROFILE_CALL(RendererManager::instance().getActive()->renderAll(), "Render");
 
 			// Core and sim thread run in lockstep. This will result in a larger input latency than if I was 

BansheeEngine/Include/BsApplication.h

@@ -80,6 +80,11 @@ namespace BansheeEngine
 		 */
 		virtual void onShutDown() override;
 
+		/**
+		 * @copydoc	CoreApplication::preUpdate.
+		 */
+		virtual void preUpdate() override;
+
 		/**
 		 * @copydoc	CoreApplication::postUpdate.
 		 */

BansheeEngine/Include/BsCamera.h

@@ -294,7 +294,6 @@ namespace BansheeEngine
 		void updateView() const;
 
 		mutable CameraHandlerPtr mInternal;
-		mutable UINT32 mLastUpdateHash;
 
 		/************************************************************************/
 		/* 						COMPONENT OVERRIDES                      		*/
@@ -305,13 +304,13 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	Component::onDestroyed
 		 */
-		void onDestroyed();
+		void onDestroyed() override;
 
 	public:
 		/**
 		 * @copydoc	Component::update
 		 */
-		virtual void update();
+		virtual void update() override;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/

BansheeEngine/Include/BsCameraHandler.h

@@ -541,17 +541,17 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	CoreObjectCore::initialize
 		 */
-		void initialize();
+		void initialize() override;
 
 		/**
 		 * @copydoc	CameraHandlerBase
 		 */
-		virtual Rect2I getViewportRect() const;
+		virtual Rect2I getViewportRect() const override;
 
 		/**
 		 * @copydoc	CoreObject::syncToCore
 		 */
-		void syncToCore(const CoreSyncData& data);
+		void syncToCore(const CoreSyncData& data) override;
 
 		SPtr<ViewportCore> mViewport;
 	};
@@ -573,6 +573,16 @@ namespace BansheeEngine
 		 */
 		SPtr<CameraHandlerCore> getCore() const;
 
+		/**
+	     * @brief	Returns the hash value that can be used to identify if the internal data needs an update.
+		 */
+		UINT32 _getLastModifiedHash() const { return mLastUpdateHash; }
+
+		/**
+	     * @brief	Sets the hash value that can be used to identify if the internal data needs an update.
+		 */
+		void _setLastModifiedHash(UINT32 hash) { mLastUpdateHash = hash; }
+
 		/**
 		 * @brief	Creates a new camera that renders to the specified portion of the provided render target.
 		 */
@@ -586,27 +596,27 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	CameraHandlerBase
 		 */
-		virtual Rect2I getViewportRect() const;
+		virtual Rect2I getViewportRect() const override;
 
 		/**
 		 * @copydoc	CoreObject::createCore
 		 */
-		SPtr<CoreObjectCore> createCore() const;
+		SPtr<CoreObjectCore> createCore() const override;
 
 		/**
 		 * @copydoc	CoreObject::markCoreDirty
 		 */
-		void _markCoreDirty();
+		void _markCoreDirty() override;
 
 		/**
 		 * @copydoc	CoreObject::syncToCore
 		 */
-		CoreSyncData syncToCore(FrameAlloc* allocator);
+		CoreSyncData syncToCore(FrameAlloc* allocator) override;
 
 		/**
 		 * @copydoc	CoreObject::getCoreDependencies
 		 */
-		void getCoreDependencies(Vector<SPtr<CoreObject>>& dependencies);
+		void getCoreDependencies(Vector<SPtr<CoreObject>>& dependencies) override;
 
 		/**
 		 * @brief	Creates a new camera without initializing it.
@@ -614,6 +624,7 @@ namespace BansheeEngine
 		static CameraHandlerPtr createEmpty();
 
 		ViewportPtr mViewport; /**< Viewport that describes 2D rendering surface. */
+		UINT32 mLastUpdateHash;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/

BansheeEngine/Include/BsRenderable.h

@@ -66,7 +66,6 @@ namespace BansheeEngine
 		void updateTransform() const;
 
 		mutable RenderableHandlerPtr mInternal;
-		mutable UINT32 mLastUpdateHash;
 
 		/************************************************************************/
 		/* 							COMPONENT OVERRIDES                    		*/
@@ -80,18 +79,18 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	Component::onInitialized
 		 */
-		void onInitialized();
+		void onInitialized() override;
 
 		/**
 		 * @copydoc	Component::onDestroyed
 		 */
-		void onDestroyed();
+		void onDestroyed() override;
 
 	public:
 		/**
 		 * @copydoc	Component::update
 		 */
-		virtual void update();
+		virtual void update() override;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/
@@ -99,7 +98,7 @@ namespace BansheeEngine
 	public:
 		friend class RenderableRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		virtual RTTITypeBase* getRTTI() const override;
 
 	protected:
 		Renderable() {} // Serialization only

BansheeEngine/Include/BsRenderableHandler.h

@@ -173,12 +173,12 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	RenderableHandlerCore::initialize
 		 */
-		void initialize();
+		void initialize() override;
 
 		/**
 		 * @copydoc	CoreObject::syncToCore
 		 */
-		void syncToCore(const CoreSyncData& data);
+		void syncToCore(const CoreSyncData& data) override;
 
 		UINT32 mRendererId;
 	};
@@ -200,64 +200,76 @@ namespace BansheeEngine
 		 */
 		SPtr<RenderableHandlerCore> getCore() const;
 
+		/**
+	     * @brief	Returns the hash value that can be used to identify if the internal data needs an update.
+		 */
+		UINT32 _getLastModifiedHash() const { return mLastUpdateHash; }
+
+		/**
+	     * @brief	Sets the hash value that can be used to identify if the internal data needs an update.
+		 */
+		void _setLastModifiedHash(UINT32 hash) { mLastUpdateHash = hash; }
+
 		/**
 		 * @brief	Creates a new renderable handler instance.
 		 */
 		static RenderableHandlerPtr create();
 
 	protected:
-		RenderableHandler() { }
+		RenderableHandler();
 
 		/**
 		 * @copydoc	CoreObject::createCore
 		 */
-		SPtr<CoreObjectCore> createCore() const;
+		SPtr<CoreObjectCore> createCore() const override;
 
 		/**
 		 * @copydoc	CoreObject::markCoreDirty
 		 */
-		void _markCoreDirty(RenderableDirtyFlag flag = RenderableDirtyFlag::Everything);
+		void _markCoreDirty(RenderableDirtyFlag flag = RenderableDirtyFlag::Everything) override;
 
 		/**
 		 * @copydoc	IResourceListener::markResourcesDirty
 		 */
-		void _markResourcesDirty();
+		void _markResourcesDirty() override;
 
 		/**
 		 * @copydoc	CoreObject::syncToCore
 		 */
-		CoreSyncData syncToCore(FrameAlloc* allocator);
+		CoreSyncData syncToCore(FrameAlloc* allocator) override;
 
 		/**
 		 * @copydoc	CoreObject::getCoreDependencies
 		 */
-		void getCoreDependencies(Vector<SPtr<CoreObject>>& dependencies);
+		void getCoreDependencies(Vector<SPtr<CoreObject>>& dependencies) override;
 
 		/**
 		 * @copydoc	IResourceListener::getResourceDependencies
 		 */
-		void getListenerResources(Vector<HResource>& resources);
+		void getListenerResources(Vector<HResource>& resources) override;
 
 		/**
 		 * @copydoc IResourceListener::notifyResourceLoaded
 		 */
-		void notifyResourceLoaded(const HResource& resource) { markCoreDirty(); }
+		void notifyResourceLoaded(const HResource& resource) override { markCoreDirty(); }
 
 		/**
 		 * @copydoc IResourceListener::notifyResourceDestroyed
 		 */
-		void notifyResourceDestroyed(const HResource& resource) { markCoreDirty(); }
+		void notifyResourceDestroyed(const HResource& resource) override { markCoreDirty(); }
 
 		/**
 		 * @copydoc IResourceListener::notifyResourceChanged
 		 */
-		void notifyResourceChanged(const HResource& resource) { markCoreDirty(); }
+		void notifyResourceChanged(const HResource& resource) override { markCoreDirty(); }
 
 		/**
 		 * @brief	Creates a new renderable handler instance without initializing it.
 		 */
 		static RenderableHandlerPtr createEmpty();
 
+		UINT32 mLastUpdateHash;
+
 		/************************************************************************/
 		/* 								RTTI		                     		*/
 		/************************************************************************/

BansheeEngine/Include/BsSceneManager.h

@@ -101,6 +101,11 @@ namespace BansheeEngine
 		 */
 		void _unregisterCamera(const SPtr<CameraHandler>& camera);
 
+		/**
+		 * @copydoc	CoreSceneManager::_updateCoreObjectTransforms
+		 */
+		virtual void _updateCoreObjectTransforms() override;
+
 		/**
 		 * @copydoc	CoreSceneManager::instance
 		 */

BansheeEngine/Source/BsApplication.cpp

@@ -111,11 +111,17 @@ namespace BansheeEngine
 		CoreApplication::startUp<Application>(primaryWindowDesc, renderSystem, renderer);
 	}
 
+	void Application::preUpdate()
+	{
+		CoreApplication::preUpdate();
+
+		VirtualInput::instance()._update();
+	}
+
 	void Application::postUpdate()
 	{
 		CoreApplication::postUpdate();
 
-		VirtualInput::instance()._update();
 		PROFILE_CALL(GUIManager::instance().update(), "GUI");
 	}
 

BansheeEngine/Source/BsCamera.cpp

@@ -17,7 +17,7 @@
 namespace BansheeEngine 
 {
 	Camera::Camera(const HSceneObject& parent, RenderTargetPtr target, float left, float top, float width, float height)
-		: Component(parent), mLastUpdateHash(std::numeric_limits<UINT32>::max())
+		: Component(parent)
     {
 		mInternal = CameraHandler::create(target, left, top, width, height);
 		gSceneManager()._registerCamera(mInternal, parent);
@@ -49,18 +49,18 @@ namespace BansheeEngine
 	void Camera::updateView() const
 	{
 		UINT32 curHash = SO()->getTransformHash();
-		if (curHash != mLastUpdateHash)
+		if (curHash != mInternal->_getLastModifiedHash())
 		{
 			mInternal->setPosition(SO()->getWorldPosition());
 			mInternal->setRotation(SO()->getWorldRotation());
 
-			mLastUpdateHash = curHash;
+			mInternal->_setLastModifiedHash(curHash);
 		}
 	}
 
 	void Camera::update() 
 	{
-		updateView();
+
 	}
 
 	void Camera::onDestroyed()

BansheeEngine/Source/BsCameraHandler.cpp

@@ -728,6 +728,7 @@ namespace BansheeEngine
 	}
 
 	CameraHandler::CameraHandler(RenderTargetPtr target, float left, float top, float width, float height)
+		:mLastUpdateHash(0)
 	{
 		if (target != nullptr)
 			target->blockUntilCoreInitialized();

BansheeEngine/Source/BsRenderable.cpp

@@ -11,7 +11,7 @@
 namespace BansheeEngine
 {
 	Renderable::Renderable(const HSceneObject& parent)
-		:Component(parent), mLastUpdateHash(0)
+		:Component(parent)
 	{
 		setName("Renderable");
 		mInternal = RenderableHandler::create();
@@ -32,22 +32,16 @@ namespace BansheeEngine
 	void Renderable::updateTransform() const
 	{
 		UINT32 curHash = SO()->getTransformHash();
-		if (curHash != mLastUpdateHash)
+		if (curHash != mInternal->_getLastModifiedHash())
 		{
 			mInternal->setTransform(SO()->getWorldTfrm());
-
-			mLastUpdateHash = curHash;
+			mInternal->_setLastModifiedHash(curHash);
 		}
 	}
 
 	void Renderable::update()
 	{
-		updateTransform();
 
-		if (SO()->getActive() != mInternal->getIsActive())
-		{
-			mInternal->setIsActive(SO()->getActive());
-		}
 	}
 
 	void Renderable::onDestroyed()

BansheeEngine/Source/BsRenderableHandler.cpp

@@ -189,6 +189,12 @@ namespace BansheeEngine
 		}
 	}
 
+	RenderableHandler::RenderableHandler()
+		:mLastUpdateHash(0)
+	{
+		
+	}
+
 	Bounds RenderableHandler::getBounds() const
 	{
 		HMesh mesh = getMesh();

BansheeEngine/Source/BsSceneManager.cpp

@@ -1,4 +1,7 @@
 #include "BsSceneManager.h"
+#include "BsSceneObject.h"
+#include "BsRenderableHandler.h"
+#include "BsCameraHandler.h"
 
 namespace BansheeEngine
 {
@@ -24,6 +27,42 @@ namespace BansheeEngine
 		mCameras.erase(camera.get());
 	}
 
+	void SceneManager::_updateCoreObjectTransforms()
+	{
+		for (auto& renderablePair : mRenderables)
+		{
+			RenderableHandlerPtr handler = renderablePair.second.renderable;
+			HSceneObject so = renderablePair.second.sceneObject;
+
+			UINT32 curHash = so->getTransformHash();
+			if (curHash != handler->_getLastModifiedHash())
+			{
+				handler->setTransform(so->getWorldTfrm());
+				handler->_setLastModifiedHash(curHash);
+			}
+
+			if (so->getActive() != handler->getIsActive())
+			{
+				handler->setIsActive(so->getActive());
+			}
+		}
+
+		for (auto& cameraPair : mCameras)
+		{
+			CameraHandlerPtr handler = cameraPair.second.camera;
+			HSceneObject so = cameraPair.second.sceneObject;
+
+			UINT32 curHash = so->getTransformHash();
+			if (curHash != handler->_getLastModifiedHash())
+			{
+				handler->setPosition(so->getWorldPosition());
+				handler->setRotation(so->getWorldRotation());
+
+				handler->_setLastModifiedHash(curHash);
+			}
+		}
+	}
+
 	SceneManager& SceneManager::instance()
 	{
 		return static_cast<SceneManager&>(CoreSceneManager::instance());

MBansheeEditor/Scene/RotateHandle.cs

@@ -82,8 +82,6 @@ namespace BansheeEditor
             }
 
             delta = Quaternion.FromEuler(xValue, yValue, zValue);
-
-            Debug.Log("ROTATION: " + Rotation);
         }
 
         protected override void Draw()

TODO.txt

@@ -58,8 +58,13 @@ Code quality improvements:
 ----------------------------------------------------------------------
 Polish stage 1
 
+Perform Renderable/Camera updates in CoreSceneManager
+ - it has a scene object + renderable/camera stored already
+ - for update all I need is those two
+ - plus a stored hash which I can move from renderable/camera to the handler
+ - Then before calling renderAll in CoreApp I can call gSceneObject().updateTransforms().
+
 Handles:
-Investigate scale and its issues
 Check multi-select move/Rotate/scale
 Free rotation handle doesn't seem to be implemented