Modified profiler overlay so it doesn't render under the geometry

Camera layers are now properly used
GUIWidget now has proper RTTI data

BansheeCore/Include/BsCorePrerequisites.h

@@ -340,7 +340,9 @@ namespace BansheeEngine
 		TID_Prefab = 1077,
 		TID_PrefabDiff = 1078,
 		TID_PrefabObjectDiff = 1079,
-		TID_PrefabComponentDiff = 1080
+		TID_PrefabComponentDiff = 1080,
+		TID_GUIWidget = 1081,
+		TID_ProfilerOverlay = 1082
 	};
 }
 

BansheeEditor/Include/BsEditorWindowBase.h

@@ -76,6 +76,11 @@ namespace BansheeEngine
 		 */
 		HGUIWidget getGUIWidget() const { return mGUI; }
 
+		/**
+		 * @brief	Returns the camera used for rendering the window GUI contents.
+		 */	
+		HCamera getGUICamera() const { return mCamera; }
+
 	protected:
 		EditorWindowBase(bool isModal = false);
 		EditorWindowBase(const RenderWindowPtr& renderWindow);

BansheeEditor/Source/BsEditorWidget.cpp

@@ -27,7 +27,10 @@ namespace BansheeEngine
 
 	EditorWindowBase* EditorWidgetBase::getParentWindow() const
 	{
-		return mParent->getParentWindow();
+		if (mParent != nullptr)
+			return mParent->getParentWindow();
+		else
+			return nullptr;
 	}
 
 	void EditorWidgetBase::close()

BansheeEditor/Source/BsEditorWindowBase.cpp

@@ -68,7 +68,7 @@ namespace BansheeEngine
 		mCamera = mSceneObject->addComponent<Camera>(renderWindow, 0.0f, 0.0f, 1.0f, 1.0f);
 		mCamera->setNearClipDistance(5);
 		mCamera->setAspectRatio(1.0f);
-		mCamera->setIgnoreSceneRenderables(true);
+		mCamera->setLayers(0);
 
 		mGUI = mSceneObject->addComponent<GUIWidget>(mCamera->getViewport().get());
 		mGUI->setDepth(128);

BansheeEngine/BansheeEngine.vcxproj

@@ -272,6 +272,7 @@
     <ClInclude Include="Include\BsGUIProgressBar.h" />
     <ClInclude Include="Include\BsGUISkinRTTI.h" />
     <ClInclude Include="Include\BsGUISlider.h" />
+    <ClInclude Include="Include\BsGUIWidgetRTTI.h" />
     <ClInclude Include="Include\BsLight.h" />
     <ClInclude Include="Include\BsLightInternal.h" />
     <ClInclude Include="Include\BsLightInternalRTTI.h" />
@@ -363,6 +364,7 @@
     <ClCompile Include="Source\BsGUIButtonBase.cpp" />
     <ClCompile Include="Source\BsGUIContextMenu.cpp" />
     <ClInclude Include="Include\BsVirtualInput.h" />
+    <ClInclude Include="Include\BsProfilerOverlayRTTI.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsApplication.cpp" />

BansheeEngine/BansheeEngine.vcxproj.filters

@@ -347,6 +347,12 @@
     <ClInclude Include="Include\BsLightRTTI.h">
       <Filter>Header Files\RTTI</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsGUIWidgetRTTI.h">
+      <Filter>Header Files\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsProfilerOverlayRTTI.h">
+      <Filter>Header Files\RTTI</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsGUIElement.cpp">

BansheeEngine/Include/BsCamera.h

@@ -175,16 +175,6 @@ namespace BansheeEngine
 		 */
 		virtual float getOrthoWindowWidth() const { return mInternal->getOrthoWindowWidth(); }
 
-		/**
-		 * @copydoc	CameraHandler::setIgnoreSceneRenderables
-		 */
-		void setIgnoreSceneRenderables(bool value) { mInternal->setIgnoreSceneRenderables(value); }
-
-		/**
-		 * @copydoc	CameraHandler::getIgnoreSceneRenderables
-		 */
-		bool getIgnoreSceneRenderables() const { return mInternal->getIgnoreSceneRenderables(); }
-
 		/**
 		 * @copydoc	CameraHandler::getPriority
 		 */

BansheeEngine/Include/BsCameraHandler.h

@@ -287,16 +287,6 @@ namespace BansheeEngine
 		 */
 		virtual float getOrthoWindowWidth() const;
 
-		/**
-		 * @brief	This option tells the renderer that this camera should ignore any renderable components.
-		 */
-		void setIgnoreSceneRenderables(bool value) { mIgnoreSceneRenderables = true; _markCoreDirty(); }
-
-		/**
-		 * @brief	This option tells the renderer that this camera should ignore any renderable components.
-		 */
-		bool getIgnoreSceneRenderables() const { return mIgnoreSceneRenderables; }
-
 		/**
 		 * @brief	Gets a priority that determines in which orders the cameras are rendered.
 		 *			This only applies to cameras rendering to the same render target. 
@@ -500,7 +490,6 @@ namespace BansheeEngine
 		bool mCustomProjMatrix; /**< Is custom projection matrix set. */
 
 		bool mFrustumExtentsManuallySet; /**< Are frustum extents manually set. */
-		bool mIgnoreSceneRenderables; /**< Should the camera ignore renderable components. */
 
 		mutable Matrix4 mProjMatrixRS; /**< Cached render-system specific projection matrix. */
 		mutable Matrix4 mProjMatrix; /**< Cached projection matrix that determines how are 3D points projected to a 2D viewport. */

BansheeEngine/Include/BsCameraHandlerRTTI.h

@@ -51,9 +51,6 @@ namespace BansheeEngine
 		bool& getFrustumManual(CameraHandler* obj) { return obj->mFrustumExtentsManuallySet; }
 		void setFrustumManual(CameraHandler* obj, bool& val) { obj->mFrustumExtentsManuallySet = val; }
 
-		bool& getIgnoreSceneRenderables(CameraHandler* obj) { return obj->mIgnoreSceneRenderables; }
-		void setIgnoreSceneRenderables(CameraHandler* obj, bool& val) { obj->mIgnoreSceneRenderables = val; }
-
 		Matrix4& getProjMatrix(CameraHandler* obj) { return obj->mProjMatrix; }
 		void setProjMatrix(CameraHandler* obj, Matrix4& val) { obj->mProjMatrix = val; }
 
@@ -92,7 +89,6 @@ namespace BansheeEngine
 			addPlainField("mCustomViewMatrix", 11, &CameraHandlerRTTI::getCustomViewMatrix, &CameraHandlerRTTI::setCustomViewMatrix);
 			addPlainField("mCustomProjMatrix", 12, &CameraHandlerRTTI::getCustomProjMatrix, &CameraHandlerRTTI::setCustomProjMatrix);
 			addPlainField("mFrustumExtentsManuallySet", 13, &CameraHandlerRTTI::getFrustumManual, &CameraHandlerRTTI::setFrustumManual);
-			addPlainField("mIgnoreSceneRenderables", 14, &CameraHandlerRTTI::getIgnoreSceneRenderables, &CameraHandlerRTTI::setIgnoreSceneRenderables);
 			addPlainField("mProjMatrixRS", 15, &CameraHandlerRTTI::getProjMatrixRS, &CameraHandlerRTTI::setProjMatrixRS);
 			addPlainField("mProjMatrix", 16, &CameraHandlerRTTI::getProjMatrix, &CameraHandlerRTTI::setProjMatrix);
 			addPlainField("mViewMatrix", 17, &CameraHandlerRTTI::getViewMatrix, &CameraHandlerRTTI::setViewMatrix);
@@ -102,24 +98,24 @@ namespace BansheeEngine
 			addPlainField("mBottom", 21, &CameraHandlerRTTI::getBottom, &CameraHandlerRTTI::setBottom);
 		}
 
-		virtual void onDeserializationEnded(IReflectable* obj)
+		virtual void onDeserializationEnded(IReflectable* obj) override
 		{
 			CameraHandler* cameraHandler = static_cast<CameraHandler*>(obj);
 			cameraHandler->initialize();
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "CameraHandler";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_CameraHandler;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return CameraHandler::createEmpty();
 		}

BansheeEngine/Include/BsGUIWidget.h

@@ -163,12 +163,12 @@ namespace BansheeEngine
 		/**
 		 * @copydoc	Component::update
 		 */
-		virtual void update();
+		virtual void update() override;
 
 		/**
 		 * @copydoc	Component::onDestroyed
 		 */
-		virtual void onDestroyed();
+		virtual void onDestroyed() override;
 	private:
 		GUIWidget(const GUIWidget& other) { }
 
@@ -201,5 +201,15 @@ namespace BansheeEngine
 		mutable Vector<HMaterial> mCachedMaterials;
 
 		HGUISkin mSkin;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class GUIWidgetRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const override;
+
+		GUIWidget() { } // Serialization only
 	};
 }

BansheeEngine/Include/BsGUIWidgetRTTI.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "BsCorePrerequisites.h"
+#include "BsRTTIType.h"
+#include "BsGUIWidget.h"
+#include "BsGameObjectRTTI.h"
+
+namespace BansheeEngine
+{
+	class BS_EXPORT GUIWidgetRTTI : public RTTIType <GUIWidget, Component, GUIWidgetRTTI>
+	{
+	private:
+
+	public:
+		GUIWidgetRTTI()
+		{ }
+
+		virtual const String& getRTTIName() override
+		{
+			static String name = "GUIWidget";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() override
+		{
+			return TID_GUIWidget;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		{
+			return GameObjectRTTI::createGameObject<GUIWidget>();
+		}
+	};
+}

BansheeEngine/Include/BsProfilerOverlay.h

@@ -55,6 +55,16 @@ namespace BansheeEngine
 
 	private:
 		ProfilerOverlayInternal* mInternal;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ProfilerOverlayRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const override;
+
+		ProfilerOverlay() { } // Serialization only
 	};
 
 	/**

BansheeEngine/Include/BsProfilerOverlayRTTI.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "BsCorePrerequisites.h"
+#include "BsRTTIType.h"
+#include "BsProfilerOverlay.h"
+#include "BsGameObjectRTTI.h"
+
+namespace BansheeEngine
+{
+	class BS_EXPORT ProfilerOverlayRTTI : public RTTIType <ProfilerOverlay, Component, ProfilerOverlayRTTI>
+	{
+	private:
+
+	public:
+		ProfilerOverlayRTTI()
+		{ }
+
+		virtual const String& getRTTIName() override
+		{
+			static String name = "ProfilerOverlay";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() override
+		{
+			return TID_ProfilerOverlay;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		{
+			return GameObjectRTTI::createGameObject<ProfilerOverlay>();
+		}
+	};
+}

BansheeEngine/Source/BsCameraHandler.cpp

@@ -20,8 +20,8 @@ namespace BansheeEngine
 	CameraHandlerBase::CameraHandlerBase(RenderTargetPtr target, float left, float top, float width, float height)
 		:mProjType(PT_PERSPECTIVE), mHorzFOV(Radian(Math::PI / 4.0f)), mFarDist(1000.0f),
 		mNearDist(0.05f), mAspect(1.33333333333333f), mOrthoHeight(1000), mRecalcFrustum(true), mRecalcFrustumPlanes(true),
-		mCustomViewMatrix(false), mCustomProjMatrix(false), mFrustumExtentsManuallySet(false), mIgnoreSceneRenderables(false),
-		mPriority(0), mLayers(0xFFFFFFFFFFFFFFFF), mRecalcView(true)
+		mCustomViewMatrix(false), mCustomProjMatrix(false), mFrustumExtentsManuallySet(false), mPriority(0), 
+		mLayers(0xFFFFFFFFFFFFFFFF), mRecalcView(true)
 	{
 		mViewMatrix = Matrix4::ZERO;
 		mProjMatrixRS = Matrix4::ZERO;
@@ -720,7 +720,6 @@ namespace BansheeEngine
 		dataPtr = rttiReadElem(mCustomViewMatrix, dataPtr);
 		dataPtr = rttiReadElem(mCustomProjMatrix, dataPtr);
 		dataPtr = rttiReadElem(mFrustumExtentsManuallySet, dataPtr);
-		dataPtr = rttiReadElem(mIgnoreSceneRenderables, dataPtr);
 
 		mRecalcFrustum = true;
 		mRecalcFrustumPlanes = true;
@@ -794,7 +793,6 @@ namespace BansheeEngine
 		size += rttiGetElemSize(mCustomProjMatrix);
 
 		size += rttiGetElemSize(mFrustumExtentsManuallySet);
-		size += rttiGetElemSize(mIgnoreSceneRenderables);
 
 		UINT8* buffer = allocator->alloc(size);
 
@@ -812,7 +810,6 @@ namespace BansheeEngine
 		dataPtr = rttiWriteElem(mCustomViewMatrix, dataPtr);
 		dataPtr = rttiWriteElem(mCustomProjMatrix, dataPtr);
 		dataPtr = rttiWriteElem(mFrustumExtentsManuallySet, dataPtr);
-		dataPtr = rttiWriteElem(mIgnoreSceneRenderables, dataPtr);
 
 		return CoreSyncData(buffer, size);
 	}

BansheeEngine/Source/BsGUIWidget.cpp

@@ -15,6 +15,7 @@
 #include "BsViewport.h"
 #include "BsSceneObject.h"
 #include "BsRenderWindow.h"
+#include "BsGUIWidgetRTTI.h"
 
 namespace BansheeEngine
 {
@@ -335,4 +336,14 @@ namespace BansheeEngine
 	{
 
 	}
+
+	RTTITypeBase* GUIWidget::getRTTIStatic()
+	{
+		return GUIWidgetRTTI::instance();
+	}
+
+	RTTITypeBase* GUIWidget::getRTTI() const
+	{
+		return GUIWidget::getRTTIStatic();
+	}
 }

BansheeEngine/Source/BsProfilerOverlay.cpp

@@ -13,6 +13,7 @@
 #include "BsBuiltinResources.h"
 #include "BsProfilingManager.h"
 #include "BsRenderTarget.h"
+#include "BsProfilerOverlayRTTI.h"
 
 namespace BansheeEngine
 {
@@ -307,6 +308,16 @@ namespace BansheeEngine
 		mInternal->update();
 	}
 
+	RTTITypeBase* ProfilerOverlay::getRTTIStatic()
+	{
+		return ProfilerOverlayRTTI::instance();
+	}
+
+	RTTITypeBase* ProfilerOverlay::getRTTI() const
+	{
+		return ProfilerOverlay::getRTTIStatic();
+	}
+
 	ProfilerOverlayInternal::ProfilerOverlayInternal(const ViewportPtr& target)
 		:mIsShown(true), mType(ProfilerOverlayType::CPUSamples)
 	{

BansheeRenderer/Source/BsBansheeRenderer.cpp

@@ -269,11 +269,11 @@ namespace BansheeEngine
 			Vector<const CameraHandlerCore*>& cameras = renderTargetData.cameras;
 
 			RenderAPICore::instance().beginFrame();
+			RenderAPICore::instance().setRenderTarget(target);
 
 			for(auto& camera : cameras)
 			{
 				SPtr<ViewportCore> viewport = camera->getViewport();
-				RenderAPICore::instance().setRenderTarget(target);
 				RenderAPICore::instance().setViewport(viewport->getNormArea());
 
 				UINT32 clearBuffers = 0;
@@ -326,60 +326,61 @@ namespace BansheeEngine
 			}
 		}
 
-		if (!camera.getIgnoreSceneRenderables())
+		UINT64 cameraLayers = camera.getLayers();
+		ConvexVolume worldFrustum = camera.getWorldFrustum();
+
+		// Update per-object param buffers and queue render elements
+		for (auto& renderableData : mRenderables)
 		{
-			ConvexVolume worldFrustum = camera.getWorldFrustum();
+			RenderableHandlerCore* renderable = renderableData.renderable;
+			RenderableController* controller = renderableData.controller;
+			UINT32 renderableType = renderable->getRenderableType();
+			UINT32 rendererId = renderable->getRendererId();
+
+			if ((renderable->getLayer() & cameraLayers) == 0)
+				continue;
 
-			// Update per-object param buffers and queue render elements
-			for (auto& renderableData : mRenderables)
+			// Update buffers
+			for (auto& renderElem : renderableData.elements)
 			{
-				RenderableHandlerCore* renderable = renderableData.renderable;
-				RenderableController* controller = renderableData.controller;
-				UINT32 renderableType = renderable->getRenderableType();
-				UINT32 rendererId = renderable->getRendererId();
+				if (controller != nullptr)
+					controller->bindPerObjectBuffers(renderElem);
 
-				// Update buffers
-				for (auto& renderElem : renderableData.elements)
+				if (renderableType == RenType_LitTextured)
 				{
-					if (controller != nullptr)
-						controller->bindPerObjectBuffers(renderElem);
+					Matrix4 worldViewProjMatrix = viewProjMatrix * mWorldTransforms[rendererId];
+					mLitTexHandler->updatePerObjectBuffers(renderElem, worldViewProjMatrix);
+				}
 
-					if (renderableType == RenType_LitTextured)
-					{
-						Matrix4 worldViewProjMatrix = viewProjMatrix * mWorldTransforms[rendererId];
-						mLitTexHandler->updatePerObjectBuffers(renderElem, worldViewProjMatrix);
-					}
+				UINT32 numPasses = renderElem.material->getNumPasses();
+				for (UINT32 i = 0; i < numPasses; i++)
+				{
+					SPtr<PassParametersCore> passParams = renderElem.material->getPassParameters(i);
 
-					UINT32 numPasses = renderElem.material->getNumPasses();
-					for (UINT32 i = 0; i < numPasses; i++)
+					for (UINT32 j = 0; j < passParams->getNumParams(); j++)
 					{
-						SPtr<PassParametersCore> passParams = renderElem.material->getPassParameters(i);
-
-						for (UINT32 j = 0; j < passParams->getNumParams(); j++)
-						{
-							SPtr<GpuParamsCore> params = passParams->getParamByIdx(j);
-							if (params != nullptr)
-								params->updateHardwareBuffers();
-						}
+						SPtr<GpuParamsCore> params = passParams->getParamByIdx(j);
+						if (params != nullptr)
+							params->updateHardwareBuffers();
 					}
 				}
+			}
 
-				// Do frustum culling
-				// TODO - This is bound to be a bottleneck at some point. When it is ensure that intersect
-				// methods use vector operations, as it is trivial to update them.
-				const Sphere& boundingSphere = mWorldBounds[rendererId].getSphere();
-				if (worldFrustum.intersects(boundingSphere))
-				{
-					// More precise with the box
-					const AABox& boundingBox = mWorldBounds[rendererId].getBox();
+			// Do frustum culling
+			// TODO - This is bound to be a bottleneck at some point. When it is ensure that intersect
+			// methods use vector operations, as it is trivial to update them.
+			const Sphere& boundingSphere = mWorldBounds[rendererId].getSphere();
+			if (worldFrustum.intersects(boundingSphere))
+			{
+				// More precise with the box
+				const AABox& boundingBox = mWorldBounds[rendererId].getBox();
 
-					if (worldFrustum.intersects(boundingBox))
-					{
-						float distanceToCamera = (camera.getPosition() - boundingBox.getCenter()).length();
+				if (worldFrustum.intersects(boundingBox))
+				{
+					float distanceToCamera = (camera.getPosition() - boundingBox.getCenter()).length();
 
-						for (auto& renderElem : renderableData.elements)
-							renderQueue->add(&renderElem, distanceToCamera);
-					}
+					for (auto& renderElem : renderableData.elements)
+						renderQueue->add(&renderElem, distanceToCamera);
 				}
 			}
 		}

ExampleProject/Main/Main.cpp

@@ -312,7 +312,7 @@ namespace BansheeEngine
 		guiCamera->setAspectRatio(1.0f);
 
 		// This camera should ignore any Renderable objects in the scene
-		guiCamera->setIgnoreSceneRenderables(true);
+		guiCamera->setLayers(0);
 
 		// Don't clear this camera as that would clear anything the main camera has rendered.
 		guiCamera->getViewport()->setRequiresClear(false, false, false);

MBansheeEditor/Scene/SceneWindow.cs

@@ -46,6 +46,7 @@ namespace BansheeEditor
 
         // Profiler overlay
         private ProfilerOverlay activeProfilerOverlay;
+        private Camera profilerCamera;
         private VirtualButton toggleProfilerOverlayKey;
 
         // Drag & drop
@@ -165,6 +166,10 @@ namespace BansheeEditor
 
         private void OnEditorUpdate()
         {
+            // DEBUG ONLY
+            if (activeProfilerOverlay != null && Time.FrameDelta > 100.0f)
+                activeProfilerOverlay.Paused = true;
+
             if (HasFocus)
             {
                 if (VirtualInput.IsButtonUp(toggleProfilerOverlayKey))
@@ -411,14 +416,24 @@ namespace BansheeEditor
             if (EditorSettings.GetBool(ProfilerOverlayActiveKey))
             {
                 if (activeProfilerOverlay == null)
-                    activeProfilerOverlay = camera.SceneObject.AddComponent<ProfilerOverlay>();
+                {
+                    SceneObject profilerSO = new SceneObject("EditorProfilerOverlay");
+                    profilerCamera = profilerSO.AddComponent<Camera>();
+                    profilerCamera.Target = renderTexture;
+                    profilerCamera.ClearFlags = ClearFlags.None;
+                    profilerCamera.Priority = 1;
+                    profilerCamera.Layers = 0;
+
+                    activeProfilerOverlay = profilerSO.AddComponent<ProfilerOverlay>();
+                }
             }
             else
             {
                 if (activeProfilerOverlay != null)
                 {
-                    activeProfilerOverlay.SceneObject.RemoveComponent<ProfilerOverlay>();
+                    activeProfilerOverlay.SceneObject.Destroy();
                     activeProfilerOverlay = null;
+                    profilerCamera = null;
                 }
             }
         }
@@ -441,7 +456,7 @@ namespace BansheeEditor
                 sceneCameraSO.Position = new Vector3(0, 0.5f, 1);
                 sceneCameraSO.LookAt(new Vector3(0, 0, 0));
 
-                camera.Priority = 1;
+                camera.Priority = 2;
                 camera.NearClipPlane = 0.005f;
                 camera.FarClipPlane = 1000.0f;
                 camera.ClearColor = ClearColor;
@@ -463,6 +478,9 @@ namespace BansheeEditor
 		    // render target destroy/create cycle for every single pixel.
 
 		    camera.AspectRatio = width / (float)height;
+
+            if (profilerCamera != null)
+                profilerCamera.Target = renderTexture;
 	    }
     }
 }

MBansheeEngine/CameraHandler.cs

@@ -16,7 +16,7 @@ namespace BansheeEngine
     [Flags]
     public enum ClearFlags
     {
-        Color = 0x01, Depth = 0x02, Stencil = 0x04
+        None = 0, Color = 0x01, Depth = 0x02, Stencil = 0x04
     }
 
     internal class CameraHandler : ScriptObject

MBansheeEngine/ProfilerOverlay.cs

@@ -16,6 +16,8 @@ namespace BansheeEngine
     {
         private ProfilerOverlayInternal impl;
 
+        public bool Paused { get; set; }
+
         public void SetType(ProfilerOverlayType type)
         {
             impl.SetType(type);   
@@ -32,7 +34,8 @@ namespace BansheeEngine
 
         private void Update()
         {
-            impl.Update();
+            if(!Paused)
+                impl.Update();
         }
 
         private void OnDestroy()

SBansheeEditor/Source/BsScriptEditorApplication.cpp

@@ -10,6 +10,12 @@
 #include "BsPrefabUtility.h"
 #include "BsSceneManager.h"
 #include "BsResources.h"
+#include "BsScriptEditorWindow.h"
+#include "BsEditorWindowBase.h"
+#include "BsProfilerOverlay.h"
+#include "BsGUIWidget.h"
+#include "BsSceneObject.h"
+#include "BsCamera.h"
 
 namespace BansheeEngine
 {

TODO.txt

@@ -58,18 +58,11 @@ Code quality improvements:
 ----------------------------------------------------------------------
 Polish stage 1
 
-Finish up profiler overlay:
- - Add a way to add generic settings in EditorSettings.cs (e.g. key/value pairs)
- - Hook that up to SceneWindow
- - Add a shortcut (e.g. F12) to open/close profile overlay
- - Test if profiler overlay works
- - Continue with profiling the hang issue
-
-There's a large hang when doing certain operations like selecting a mesh in scene, or switching from center to pivot mode (possibly GC?)
-Crash on shutdown in mono_gchandle_free
-When selecting an gizmo icon the selection seems delayed and its gizmos flash for a frame before hiding (Can't reproduce atm but I saw it)
+IMPORTANT: Overlay camera will also draw renderables
+Track down the large performance spike
+
 ProjectLibrary seems to import some files on every start-up
-Handles don't seem to move at the same speed at the selected mesh (mostly visible with move handle)
+Crash on shutdown in mono_gchandle_free
 
 First screenshot work:
 - Inspector change contents on selection (and make sure the selected object/component looks okay)