Refactored handle drawing so it properly separates out Core so it doesn't get destroyed before core methods are done

BansheeEditor/Include/BsHandleDrawManager.h

@@ -5,29 +5,12 @@
 
 namespace BansheeEngine
 {
+	class HandleDrawManagerCore;
+
 	class BS_ED_EXPORT HandleDrawManager
 	{
-		struct SolidMaterialData
-		{
-			HMaterial material;
-
-			// Core
-			MaterialProxyPtr proxy;
-			GpuParamMat4 mViewProj;
-			GpuParamMat4 mViewIT;
-		};
-
-		struct WireMaterialData
-		{
-			HMaterial material;
-
-			// Core
-			MaterialProxyPtr proxy;
-			GpuParamMat4 mViewProj;
-		};
-
 	public:
-		HandleDrawManager(const HCamera& camera);
+		HandleDrawManager();
 		~HandleDrawManager();
 
 		void setColor(const Color& color);
@@ -45,34 +28,67 @@ namespace BansheeEngine
 		void drawWireArc(const Vector3& position, const Vector3& normal, float radius, Degree startAngle, Degree amountAngle);
 		void drawRect(const Rect3& area);
 
-		void draw();
+		void draw(const HCamera& camera);
 
 	private:
-		void coreRender(const CameraProxy& camera);
-		void coreRenderSolid(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr mesh);
-		void coreRenderWire(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr mesh);
+		friend class HandleDrawManagerCore;
 
-		void coreUpdateData(const MeshProxyPtr& solidMeshProxy, const MeshProxyPtr& wireMeshProxy);
-		void initializeCore();
+		void initializeCore(const MaterialProxyPtr& wireMatProxy, const MaterialProxyPtr& solidMatProxy);
+		void destroyCore(HandleDrawManagerCore* core);
 
 		static const UINT32 SPHERE_QUALITY;
 		static const UINT32 WIRE_SPHERE_QUALITY;
 		static const UINT32 ARC_QUALITY;
 
-		HCamera mCamera;
-		RenderTargetPtr mSceneRenderTarget;
-
+		HandleDrawManagerCore* mCore;
 		DrawHelper* mDrawHelper;
 
 		TransientMeshPtr mSolidMesh;
 		TransientMeshPtr mWireMesh;
+	};
 
-		// Immutable
-		SolidMaterialData mSolidMaterial;
-		WireMaterialData mWireMaterial;
+	class BS_ED_EXPORT HandleDrawManagerCore
+	{
+		struct SolidMaterialData
+		{
+			HMaterial material;
+
+			// Core
+			MaterialProxyPtr proxy;
+			GpuParamMat4 mViewProj;
+			GpuParamMat4 mViewIT;
+		};
+
+		struct WireMaterialData
+		{
+			HMaterial material;
+
+			// Core
+			MaterialProxyPtr proxy;
+			GpuParamMat4 mViewProj;
+		};
+
+		struct PrivatelyConstruct { };
+
+	public:
+		HandleDrawManagerCore(const PrivatelyConstruct& dummy) { }
+
+	private:
+		friend class HandleDrawManager;
 
-		// Core
+		void initialize(const MaterialProxyPtr& wireMatProxy, const MaterialProxyPtr& solidMatProxy);
+
+		void updateData(const RenderTargetPtr& rt, const MeshProxyPtr& solidMeshProxy, const MeshProxyPtr& wireMeshProxy);
+		void render(const CameraProxy& camera);
+		void renderSolid(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr mesh);
+		void renderWire(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr mesh);
+
+		RenderTargetPtr mSceneRenderTarget;
 		MeshProxyPtr mSolidMeshProxy;
 		MeshProxyPtr mWireMeshProxy;
+
+		// Immutable
+		SolidMaterialData mSolidMaterial;
+		WireMaterialData mWireMaterial;
 	};
 }

BansheeEditor/Include/BsHandleManager.h

@@ -8,7 +8,7 @@ namespace BansheeEngine
 	class BS_ED_EXPORT HandleManager : public Module<HandleManager>
 	{
 	public:
-		HandleManager(const HCamera& camera);
+		HandleManager();
 		virtual ~HandleManager();
 
 		void update(const Vector2I& inputPos, const Ray& inputRay, bool pressed);
@@ -21,7 +21,6 @@ namespace BansheeEngine
 	protected:
 		HandleSliderManager* mSliderManager;
 		HandleDrawManager* mDrawManager;
-		HCamera mCamera;
 
 		virtual void refreshHandles() = 0;
 		virtual void triggerHandles() = 0;

BansheeEditor/Source/BsHandleDrawManager.cpp

@@ -16,19 +16,20 @@ namespace BansheeEngine
 	const UINT32 HandleDrawManager::WIRE_SPHERE_QUALITY = 10;
 	const UINT32 HandleDrawManager::ARC_QUALITY = 10;
 
-	HandleDrawManager::HandleDrawManager(const HCamera& camera)
-		:mCamera(camera)
+	HandleDrawManager::HandleDrawManager()
+		:mCore(nullptr)
 	{
-		mSceneRenderTarget = mCamera->getViewport()->getTarget();
 		mDrawHelper = bs_new<DrawHelper>();
 
-		mSolidMaterial.material = BuiltinEditorResources::instance().createSolidGizmoMat();
-		mWireMaterial.material = BuiltinEditorResources::instance().createWireGizmoMat();
+		HMaterial solidMaterial = BuiltinEditorResources::instance().createSolidGizmoMat();
+		HMaterial wireMaterial = BuiltinEditorResources::instance().createWireGizmoMat();
 
-		mSolidMaterial.proxy = mSolidMaterial.material->_createProxy();
-		mWireMaterial.proxy = mWireMaterial.material->_createProxy();
+		MaterialProxyPtr solidMaterialProxy = solidMaterial->_createProxy();
+		MaterialProxyPtr wireMaterialProxy = wireMaterial->_createProxy();
 
-		gCoreAccessor().queueCommand(std::bind(&HandleDrawManager::initializeCore, this));
+		mCore = bs_new<HandleDrawManagerCore>(HandleDrawManagerCore::PrivatelyConstruct());
+
+		gCoreAccessor().queueCommand(std::bind(&HandleDrawManager::initializeCore, this, solidMaterialProxy, wireMaterialProxy));
 	}
 
 	HandleDrawManager::~HandleDrawManager()
@@ -40,30 +41,22 @@ namespace BansheeEngine
 
 		if (mWireMesh != nullptr)
 			mDrawHelper->releaseWireMesh(mWireMesh);
+
+		gCoreAccessor().queueCommand(std::bind(&HandleDrawManager::destroyCore, this, mCore));
 	}
 
-	void HandleDrawManager::initializeCore()
+	void HandleDrawManager::initializeCore(const MaterialProxyPtr& wireMatProxy, const MaterialProxyPtr& solidMatProxy)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
-		// TODO - Make a better interface when dealing with parameters through proxies?
-		{
-			MaterialProxyPtr proxy = mWireMaterial.proxy;
-			GpuParamsPtr vertParams = proxy->params[proxy->passes[0].vertexProgParamsIdx];
-
-			vertParams->getParam("matViewProj", mWireMaterial.mViewProj);
-		}
-
-		{
-			MaterialProxyPtr proxy = mSolidMaterial.proxy;
-			GpuParamsPtr vertParams = proxy->params[proxy->passes[0].vertexProgParamsIdx];
+		mCore->initialize(wireMatProxy, solidMatProxy);
+	}
 
-			vertParams->getParam("matViewProj", mSolidMaterial.mViewProj);
-			vertParams->getParam("matViewIT", mSolidMaterial.mViewIT);
-		}
+	void HandleDrawManager::destroyCore(HandleDrawManagerCore* core)
+	{
+		THROW_IF_NOT_CORE_THREAD;
 
-		RendererPtr activeRenderer = RendererManager::instance().getActive();
-		activeRenderer->onCorePostRenderViewport.connect(std::bind(&HandleDrawManager::coreRender, this, _1));
+		bs_delete(core);
 	}
 
 	void HandleDrawManager::setColor(const Color& color)
@@ -131,7 +124,7 @@ namespace BansheeEngine
 		mDrawHelper->rectangle(area);
 	}
 
-	void HandleDrawManager::draw()
+	void HandleDrawManager::draw(const HCamera& camera)
 	{
 		if (mSolidMesh != nullptr)
 			mDrawHelper->releaseSolidMesh(mSolidMesh);
@@ -145,18 +138,44 @@ namespace BansheeEngine
 		MeshProxyPtr solidMeshProxy = mSolidMesh->_createProxy(0);
 		MeshProxyPtr wireMeshProxy = mWireMesh->_createProxy(0);
 
-		gCoreAccessor().queueCommand(std::bind(&HandleDrawManager::coreUpdateData, this, solidMeshProxy, wireMeshProxy));
+		RenderTargetPtr sceneRenderTarget = camera->getViewport()->getTarget();
+
+		gCoreAccessor().queueCommand(std::bind(&HandleDrawManagerCore::updateData, mCore, 
+			sceneRenderTarget, solidMeshProxy, wireMeshProxy));
 
 		mDrawHelper->clear();
 	}
 
-	void HandleDrawManager::coreUpdateData(const MeshProxyPtr& solidMeshProxy, const MeshProxyPtr& wireMeshProxy)
+	void HandleDrawManagerCore::initialize(const MaterialProxyPtr& wireMatProxy, const MaterialProxyPtr& solidMatProxy)
+	{
+		// TODO - Make a better interface when dealing with parameters through proxies?
+		{
+			MaterialProxyPtr proxy = mWireMaterial.proxy;
+			GpuParamsPtr vertParams = proxy->params[proxy->passes[0].vertexProgParamsIdx];
+
+			vertParams->getParam("matViewProj", mWireMaterial.mViewProj);
+		}
+
+		{
+			MaterialProxyPtr proxy = mSolidMaterial.proxy;
+			GpuParamsPtr vertParams = proxy->params[proxy->passes[0].vertexProgParamsIdx];
+
+			vertParams->getParam("matViewProj", mSolidMaterial.mViewProj);
+			vertParams->getParam("matViewIT", mSolidMaterial.mViewIT);
+		}
+
+		RendererPtr activeRenderer = RendererManager::instance().getActive();
+		activeRenderer->onCorePostRenderViewport.connect(std::bind(&HandleDrawManagerCore::render, this, _1));
+	}
+
+	void HandleDrawManagerCore::updateData(const RenderTargetPtr& rt, const MeshProxyPtr& solidMeshProxy, const MeshProxyPtr& wireMeshProxy)
 	{
+		mSceneRenderTarget = rt;
 		mSolidMeshProxy = solidMeshProxy;
 		mWireMeshProxy = wireMeshProxy;
 	}
 
-	void HandleDrawManager::coreRender(const CameraProxy& camera)
+	void HandleDrawManagerCore::render(const CameraProxy& camera)
 	{
 		if (camera.viewport.getTarget() != mSceneRenderTarget)
 			return;
@@ -172,11 +191,11 @@ namespace BansheeEngine
 		screenArea.width = (int)(normArea.width * width);
 		screenArea.height = (int)(normArea.height * height);
 
-		coreRenderSolid(camera.viewMatrix, camera.projMatrix, mSolidMeshProxy);
-		coreRenderWire(camera.viewMatrix, camera.projMatrix, mWireMeshProxy);
+		renderSolid(camera.viewMatrix, camera.projMatrix, mSolidMeshProxy);
+		renderWire(camera.viewMatrix, camera.projMatrix, mWireMeshProxy);
 	}
 
-	void HandleDrawManager::coreRenderSolid(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr meshProxy)
+	void HandleDrawManagerCore::renderSolid(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr meshProxy)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -190,7 +209,7 @@ namespace BansheeEngine
 		Renderer::draw(*meshProxy);
 	}
 
-	void HandleDrawManager::coreRenderWire(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr meshProxy)
+	void HandleDrawManagerCore::renderWire(Matrix4 viewMatrix, Matrix4 projMatrix, MeshProxyPtr meshProxy)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 

BansheeEditor/Source/BsHandleManager.cpp

@@ -1,14 +1,15 @@
 #include "BsHandleManager.h"
 #include "BsHandleDrawManager.h"
 #include "BsHandleSliderManager.h"
+#include "BsSceneEditorWidget.h"
 
 namespace BansheeEngine
 {
-	HandleManager::HandleManager(const HCamera& camera)
-		:mSliderManager(nullptr), mDrawManager(nullptr), mCamera(camera)
+	HandleManager::HandleManager()
+		:mSliderManager(nullptr), mDrawManager(nullptr)
 	{
 		mSliderManager = bs_new<HandleSliderManager>();
-		mDrawManager = bs_new<HandleDrawManager>(camera);
+		mDrawManager = bs_new<HandleDrawManager>();
 	}
 
 	HandleManager::~HandleManager()
@@ -24,14 +25,20 @@ namespace BansheeEngine
 
 	void HandleManager::update(const Vector2I& inputPos, const Ray& inputRay, bool pressed)
 	{
-		refreshHandles();
+		SceneEditorWidget* sceneView = SceneViewLocator::instance();
+		if (sceneView != nullptr)
+		{
+			HCamera sceneCamera = sceneView->getSceneCamera();
 
-		mSliderManager->update(mCamera, inputPos, inputRay, pressed);
+			refreshHandles();
 
-		triggerHandles();
+			mSliderManager->update(sceneCamera, inputPos, inputRay, pressed);
 
-		queueDrawCommands();
+			triggerHandles();
 
-		mDrawManager->draw();
+			queueDrawCommands();
+
+			mDrawManager->draw(sceneCamera);
+		}
 	}
 }

SBansheeEditor/Include/BsScriptHandleManager.h

@@ -29,7 +29,7 @@ namespace BansheeEngine
 		};
 
 	public:
-		ScriptHandleManager(const HCamera& camera, RuntimeScriptObjects& scriptObjectManager);
+		ScriptHandleManager(RuntimeScriptObjects& scriptObjectManager);
 		~ScriptHandleManager();
 
 		void update();

SBansheeEditor/Source/BsScriptHandleManager.cpp

@@ -14,8 +14,8 @@ using namespace std::placeholders;
 
 namespace BansheeEngine
 {
-	ScriptHandleManager::ScriptHandleManager(const HCamera& camera, RuntimeScriptObjects& scriptObjectManager)
-		:HandleManager(camera), mScriptObjectManager(scriptObjectManager)
+	ScriptHandleManager::ScriptHandleManager(RuntimeScriptObjects& scriptObjectManager)
+		:mScriptObjectManager(scriptObjectManager)
 	{
 		mAssemblyRefreshedConn = mScriptObjectManager.onAssemblyRefreshed.connect(std::bind(&ScriptHandleManager::reloadAssembly, this, _1));
 

SceneView.txt

@@ -11,7 +11,6 @@ TESTING:
  - Ensure that selecting an item in scene or resource tree view properly updates Selection
 
 Test gizmos
- - Test all solid/wire gizmos shapes on all render systems
  - Test rendering of icon gizmos
  - HOOK UP GIZMO SELECTION and test it
 
@@ -23,7 +22,7 @@ Test handles
 
 IMPLEMENT SELECTION RENDERING
 
-IMPROVE SceneGrid LOOK AND ENSURE IT RENDERS FINE ON ALL APIS
+IMPROVE SceneGrid LOOK
  - LIKELY USE PIXEL SceneGrid WITH AA
 
 Need a way to drag and drop items from Scene tree view to Scene view
@@ -117,4 +116,28 @@ SceneView editor flow:
         return
      Otheriwse its assumed we are dragging a selection
         Do nothing
-        return
+        return
+
+---------------------------------------------------------------------
+Multi-resources
+
+ Importer::import
+  - Each SpecificImporter is responsible for importing all needed resources and registering them with Resources manager
+  - However only the main resource is returned from that method
+  - Rest of the resources are referenced by the UUID in ResourceMeta and can be retrieved there if needed
+
+ Resources::save
+  - Add to documentation that it will only save that exact resource and not any dependencies, you must call save() for them manually
+
+ Resources::load
+  - Will automatically load all dependencies, optionally add a boolean that allows you to load only the main asset
+
+ProjectLibrary
+ - Needs to be extended so it shows sub-resources in tree view
+ - Need to extend my mapping so one asset maps to multiple assets in library (need to remember how I do that currently, is it just by name or meta-file identifier?)
+
+---------------------
+
+With this approach I can:
+ - Reference and load the sub-resources directly
+ - Technically I can also delete sub-resources