Added basic drop overlay mesh and material

BansheeEngine/BansheeEngine.vcxproj

@@ -266,7 +266,6 @@
     <ClInclude Include="Include\BsGUISkin.h" />
     <ClInclude Include="Include\BsGUIWidget.h" />
     <ClInclude Include="Include\BsImageSprite.h" />
-    <ClInclude Include="Include\BsRendererSort.h" />
     <ClInclude Include="Include\BsSceneManager.h" />
     <ClInclude Include="Include\BsGUIScrollArea.h" />
     <ClInclude Include="Include\BsSprite.h" />

BansheeEngine/BansheeEngine.vcxproj.filters

@@ -195,9 +195,6 @@
     <ClInclude Include="Include\BsGUIViewport.h">
       <Filter>Header Files\GUI</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsRendererSort.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\BsDrawHelper2D.h">
       <Filter>Header Files</Filter>
     </ClInclude>

BansheeEngine/Include/BsBuiltinMaterialManager.h

@@ -20,6 +20,7 @@ namespace BansheeEngine
 		virtual CM::HMaterial createDebugDraw2DClipSpaceMaterial() const = 0;
 		virtual CM::HMaterial createDebugDraw2DScreenSpaceMaterial() const = 0;
 		virtual CM::HMaterial createDebugDraw3DMaterial() const = 0;
+		virtual CM::HMaterial createDockDropOverlayMaterial() const = 0;
 	};
 
 	/**
@@ -38,6 +39,7 @@ namespace BansheeEngine
 		CM::HMaterial createDebugDraw2DClipSpaceMaterial() const;
 		CM::HMaterial createDebugDraw2DScreenSpaceMaterial() const;
 		CM::HMaterial createDebugDraw3DMaterial() const;
+		CM::HMaterial createDockDropOverlayMaterial() const;
 
 		void addFactory(BuiltinMaterialFactory* factory);
 		void setActive(const CM::String& renderSystemName);

BansheeEngine/Include/BsD3D11BuiltinMaterialFactory.h

@@ -20,6 +20,7 @@ namespace BansheeEngine
 		CM::HMaterial createDebugDraw2DClipSpaceMaterial() const;
 		CM::HMaterial createDebugDraw2DScreenSpaceMaterial() const;
 		CM::HMaterial createDebugDraw3DMaterial() const;
+		CM::HMaterial createDockDropOverlayMaterial() const;
 
 	protected:
 		CM::ShaderPtr mSpriteTextShader;
@@ -27,6 +28,7 @@ namespace BansheeEngine
 		CM::ShaderPtr mDebugDraw2DClipSpaceShader;
 		CM::ShaderPtr mDebugDraw2DScreenSpaceShader;
 		CM::ShaderPtr mDebugDraw3DShader;
+		CM::ShaderPtr mDockDropOverlayShader;
 
 		CM::HSamplerState mGUISamplerState;
 
@@ -35,5 +37,6 @@ namespace BansheeEngine
 		void initDebugDraw2DClipSpaceShader();
 		void initDebugDraw2DScreenSpaceShader();
 		void initDebugDraw3DShader();
+		void initDockDropOverlayShader();
 	};
 }

BansheeEngine/Include/BsD3D9BuiltinMaterialFactory.h

@@ -20,6 +20,7 @@ namespace BansheeEngine
 		CM::HMaterial createDebugDraw2DClipSpaceMaterial() const;
 		CM::HMaterial createDebugDraw2DScreenSpaceMaterial() const;
 		CM::HMaterial createDebugDraw3DMaterial() const;
+		CM::HMaterial createDockDropOverlayMaterial() const;
 
 	protected:
 		CM::ShaderPtr mSpriteTextShader;
@@ -27,6 +28,7 @@ namespace BansheeEngine
 		CM::ShaderPtr mDebugDraw2DClipSpaceShader;
 		CM::ShaderPtr mDebugDraw2DScreenSpaceShader;
 		CM::ShaderPtr mDebugDraw3DShader;
+		CM::ShaderPtr mDockDropOverlayShader;
 
 		CM::HSamplerState mGUISamplerState;
 
@@ -35,5 +37,6 @@ namespace BansheeEngine
 		void initDebugDraw2DClipSpaceShader();
 		void initDebugDraw2DScreenSpaceShader();
 		void initDebugDraw3DShader();
+		void initDockDropOverlayShader();
 	};
 }

BansheeEngine/Include/BsGLBuiltinMaterialFactory.h

@@ -20,6 +20,7 @@ namespace BansheeEngine
 		CM::HMaterial createDebugDraw2DClipSpaceMaterial() const;
 		CM::HMaterial createDebugDraw2DScreenSpaceMaterial() const;
 		CM::HMaterial createDebugDraw3DMaterial() const;
+		CM::HMaterial createDockDropOverlayMaterial() const;
 
 	protected:
 		CM::ShaderPtr mSpriteTextShader;
@@ -27,6 +28,7 @@ namespace BansheeEngine
 		CM::ShaderPtr mDebugDraw2DClipSpaceShader;
 		CM::ShaderPtr mDebugDraw2DScreenSpaceShader;
 		CM::ShaderPtr mDebugDraw3DShader;
+		CM::ShaderPtr mDockDropOverlayShader;
 
 		CM::HSamplerState mGUISamplerState;
 
@@ -35,5 +37,6 @@ namespace BansheeEngine
 		void initDebugDraw2DClipSpaceShader();
 		void initDebugDraw2DScreenSpaceShader();
 		void initDebugDraw3DShader();
+		void initDockDropOverlayShader();
 	};
 }

BansheeEngine/Include/BsRendererSort.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-
-namespace BansheeEngine 
-{
-	enum class DepthSortOrder
-	{
-		FrontToBack,
-		BackToFront,
-		NoDepthSort
-	};
-
-	struct BS_EXPORT SortedRenderOp
-	{
-		SortedRenderOp(const RenderOperation& op)
-			:baseOperation(op), passIdx(0)
-		{ }
-
-		const RenderOperation& baseOperation;
-		CM::UINT32 passIdx;
-	};
-
-	class BS_EXPORT RendererSort
-	{
-	public:
-		virtual CM::Vector<SortedRenderOp>::type sort(const HCamera& camera, const CM::Vector<RenderOperation>::type& renderOperations, DepthSortOrder sortOrder, bool allowSortByPass) = 0;
-	};
-}

BansheeEngine/Source/BsBuiltinMaterialManager.cpp

@@ -54,6 +54,13 @@ namespace BansheeEngine
 		return mActiveFactory->createDebugDraw3DMaterial();
 	}
 
+	CM::HMaterial BuiltinMaterialManager::createDockDropOverlayMaterial() const
+	{
+		assert(mActiveFactory != nullptr);
+
+		return mActiveFactory->createDockDropOverlayMaterial();
+	}
+
 	void BuiltinMaterialManager::addFactory(BuiltinMaterialFactory* factory)
 	{
 		assert(factory != nullptr);

BansheeEngine/Source/BsD3D11BuiltinMaterialFactory.cpp

@@ -19,6 +19,7 @@ namespace BansheeEngine
 		initDebugDraw2DClipSpaceShader();
 		initDebugDraw2DScreenSpaceShader();
 		initDebugDraw3DShader();
+		initDockDropOverlayShader();
 
 		SAMPLER_STATE_DESC ssDesc;
 		ssDesc.magFilter = FO_POINT;
@@ -35,6 +36,7 @@ namespace BansheeEngine
 		mDebugDraw2DClipSpaceShader = nullptr;
 		mDebugDraw2DScreenSpaceShader = nullptr;
 		mDebugDraw3DShader = nullptr;
+		mDockDropOverlayShader = nullptr;
 	}
 
 	const CM::String& D3D11BuiltinMaterialFactory::getSupportedRenderSystem() const
@@ -75,6 +77,11 @@ namespace BansheeEngine
 		return Material::create(mDebugDraw3DShader);
 	}
 
+	HMaterial D3D11BuiltinMaterialFactory::createDockDropOverlayMaterial() const
+	{
+		return Material::create(mDockDropOverlayShader);
+	}
+
 	void D3D11BuiltinMaterialFactory::initSpriteTextShader()
 	{
 		String vsCode = "										\
@@ -367,4 +374,77 @@ namespace BansheeEngine
 		HBlendState blendState = BlendState::create(desc);
 		newPass->setBlendState(blendState);
 	}
+
+	void D3D11BuiltinMaterialFactory::initDockDropOverlayShader()
+	{
+		String vsCode = "									\
+						float invViewportWidth;				\
+						float invViewportHeight;			\
+						\
+						float4 tintColor;					\
+						float4 highlightColor;				\
+						float4 highlightActive;				\
+						\
+						void vs_main(						\
+						in float2 inPos : POSITION,			\
+						in float4 color : COLOR0,			\
+						out float4 oPosition : SV_Position, \
+						out float4 oColor : COLOR0)			\
+						{														\
+						float tfrmdX = -1.0f + (inPos.x * invViewportWidth);	\
+						float tfrmdY = 1.0f - (inPos.y * invViewportHeight);	\
+						\
+						oPosition = float4(tfrmdX, tfrmdY, 0, 1);				\
+																				\
+						float4 highlight = highlightActive * color;				\
+						float highlightSum = highlight.x + highlight.y +		\
+							highlight.y + highlight.z;							\
+																				\
+						oColor = (1.0f - highlightSum) * tintColor +			\
+							highlightSum * highlightColor;						\
+						}";
+
+		String psCode = "																		\
+						float4 ps_main(in float4 inPos : SV_Position, in float4 color : COLOR0) : SV_Target		\
+						{																						\
+						return color;																		\
+						}																						\
+						";	
+
+		HHighLevelGpuProgram vsProgram = HighLevelGpuProgram::create(vsCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
+		HHighLevelGpuProgram psProgram = HighLevelGpuProgram::create(psCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_4_0);
+
+		vsProgram.synchronize();
+		psProgram.synchronize();
+
+		mDockDropOverlayShader = Shader::create("DockDropOverlayShader");
+
+		mDockDropOverlayShader->addParameter("invViewportWidth", "invViewportWidth", GPDT_FLOAT1);
+		mDockDropOverlayShader->addParameter("invViewportHeight", "invViewportHeight", GPDT_FLOAT1);
+
+		mDockDropOverlayShader->addParameter("tintColor", "tintColor", GPDT_FLOAT4);
+		mDockDropOverlayShader->addParameter("highlightColor", "highlightColor", GPDT_FLOAT4);
+		mDockDropOverlayShader->addParameter("highlightActive", "highlightActive", GPDT_FLOAT4);
+
+		TechniquePtr newTechnique = mDockDropOverlayShader->addTechnique("D3D11RenderSystem", RendererManager::getCoreRendererName()); 
+		PassPtr newPass = newTechnique->addPass();
+		newPass->setVertexProgram(vsProgram);
+		newPass->setFragmentProgram(psProgram);
+
+		BLEND_STATE_DESC desc;
+		desc.renderTargetDesc[0].blendEnable = true;
+		desc.renderTargetDesc[0].srcBlend = BF_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].dstBlend = BF_INV_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].blendOp = BO_ADD;
+
+		HBlendState blendState = BlendState::create(desc);
+		newPass->setBlendState(blendState);
+
+		DEPTH_STENCIL_STATE_DESC depthStateDesc;
+		depthStateDesc.depthReadEnable = false;
+		depthStateDesc.depthWriteEnable = false;
+
+		HDepthStencilState depthState = DepthStencilState::create(depthStateDesc);
+		newPass->setDepthStencilState(depthState);
+	}
 }

BansheeEngine/Source/BsD3D9BuiltinMaterialFactory.cpp

@@ -19,6 +19,7 @@ namespace BansheeEngine
 		initDebugDraw2DClipSpaceShader();
 		initDebugDraw2DScreenSpaceShader();
 		initDebugDraw3DShader();
+		initDockDropOverlayShader();
 
 		SAMPLER_STATE_DESC ssDesc;
 		ssDesc.magFilter = FO_POINT;
@@ -35,6 +36,7 @@ namespace BansheeEngine
 		mDebugDraw2DClipSpaceShader = nullptr;
 		mDebugDraw2DScreenSpaceShader = nullptr;
 		mDebugDraw3DShader = nullptr;
+		mDockDropOverlayShader = nullptr;
 	}
 
 	const CM::String& D3D9BuiltinMaterialFactory::getSupportedRenderSystem() const
@@ -75,6 +77,11 @@ namespace BansheeEngine
 		return Material::create(mDebugDraw3DShader);
 	}
 
+	HMaterial D3D9BuiltinMaterialFactory::createDockDropOverlayMaterial() const
+	{
+		return Material::create(mDockDropOverlayShader);
+	}
+
 	void D3D9BuiltinMaterialFactory::initSpriteTextShader()
 	{
 		String vsCode = "										\
@@ -365,4 +372,77 @@ namespace BansheeEngine
 		HBlendState blendState = BlendState::create(desc);
 		newPass->setBlendState(blendState);
 	}
+
+	void D3D9BuiltinMaterialFactory::initDockDropOverlayShader()
+	{
+		String vsCode = "										\
+						float invViewportWidth;					\
+						float invViewportHeight;				\
+						\
+						float4 tintColor;						\
+						float4 highlightColor;					\
+						float4 highlightActive;					\
+						\
+						void vs_main(							\
+						in float2 inPos : POSITION,				\
+						in float4 inColor : COLOR0,				\
+						out float4 oPosition : POSITION,		\
+						out float4 oColor : COLOR0)				\
+						{										\
+						float tfrmdX = -1.0f + ((inPos.x - 0.5f) * invViewportWidth);			\
+						float tfrmdY = 1.0f - ((inPos.y - 0.5f) * invViewportHeight);			\
+						\
+						oPosition = float4(tfrmdX, tfrmdY, 0, 1);				\
+																				\
+						float4 highlight = highlightActive * color;				\
+						float highlightSum = highlight.x + highlight.y +		\
+						highlight.y + highlight.z;								\
+																				\
+						oColor = (1.0f - highlightSum) * tintColor +			\
+						highlightSum * highlightColor;							\
+						}														\
+						";
+
+		String psCode = "												\
+						float4 ps_main(float4 color : COLOR0) : COLOR0	\
+						{												\
+						return color;									\
+						}";
+
+		HHighLevelGpuProgram vsProgram = HighLevelGpuProgram::create(vsCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
+		HHighLevelGpuProgram psProgram = HighLevelGpuProgram::create(psCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
+
+		vsProgram.synchronize();
+		psProgram.synchronize();
+
+		mDockDropOverlayShader = Shader::create("DockDropOverlayShader");
+
+		mDockDropOverlayShader->addParameter("invViewportWidth", "invViewportWidth", GPDT_FLOAT1);
+		mDockDropOverlayShader->addParameter("invViewportHeight", "invViewportHeight", GPDT_FLOAT1);
+
+		mDockDropOverlayShader->addParameter("tintColor", "tintColor", GPDT_FLOAT4);
+		mDockDropOverlayShader->addParameter("highlightColor", "highlightColor", GPDT_FLOAT4);
+		mDockDropOverlayShader->addParameter("highlightActive", "highlightActive", GPDT_FLOAT4);
+
+		TechniquePtr newTechnique = mDockDropOverlayShader->addTechnique("D3D9RenderSystem", RendererManager::getCoreRendererName()); 
+		PassPtr newPass = newTechnique->addPass();
+		newPass->setVertexProgram(vsProgram);
+		newPass->setFragmentProgram(psProgram);
+
+		BLEND_STATE_DESC desc;
+		desc.renderTargetDesc[0].blendEnable = true;
+		desc.renderTargetDesc[0].srcBlend = BF_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].dstBlend = BF_INV_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].blendOp = BO_ADD;
+
+		HBlendState blendState = BlendState::create(desc);
+		newPass->setBlendState(blendState);
+
+		DEPTH_STENCIL_STATE_DESC depthStateDesc;
+		depthStateDesc.depthReadEnable = false;
+		depthStateDesc.depthWriteEnable = false;
+
+		HDepthStencilState depthState = DepthStencilState::create(depthStateDesc);
+		newPass->setDepthStencilState(depthState);
+	}
 }

BansheeEngine/Source/BsGLBuiltinMaterialFactory.cpp

@@ -35,6 +35,7 @@ namespace BansheeEngine
 		mDebugDraw2DClipSpaceShader = nullptr;
 		mDebugDraw2DScreenSpaceShader = nullptr;
 		mDebugDraw3DShader = nullptr;
+		mDockDropOverlayShader = nullptr;
 	}
 
 	const CM::String& GLBuiltinMaterialFactory::getSupportedRenderSystem() const
@@ -75,6 +76,11 @@ namespace BansheeEngine
 		return Material::create(mDebugDraw3DShader);
 	}
 
+	HMaterial GLBuiltinMaterialFactory::createDockDropOverlayMaterial() const
+	{
+		return Material::create(mDockDropOverlayShader);
+	}
+
 	void GLBuiltinMaterialFactory::initSpriteTextShader()
 	{
 		String vsCode = "#version 400\n							\
@@ -384,4 +390,81 @@ namespace BansheeEngine
 		HBlendState blendState = BlendState::create(desc);
 		newPass->setBlendState(blendState);
 	}
+
+	void GLBuiltinMaterialFactory::initDockDropOverlayShader()
+	{
+		String vsCode = "#version 400\n								\
+						\
+						uniform float invViewportWidth;				\
+						uniform float invViewportHeight;			\
+						\
+						uniform vec4 tintColor;						\
+						uniform vec4 highlightColor;				\
+						uniform vec4 highlightActive;				\
+						\
+						in vec2 cm_position;						\
+						in vec4 cm_color0;							\
+						out vec4 color0;							\
+						\
+						void main()									\
+						{											\
+						float tfrmdX = -1.0f + (cm_position.x * invViewportWidth);				\
+						float tfrmdY = 1.0f - (cm_position.y * invViewportHeight);				\
+						\
+						gl_Position = vec4(tfrmdX, tfrmdY, 0, 1);	\
+						\
+						float4 highlight = highlightActive * cm_color0;			\
+						float highlightSum = highlight.x + highlight.y +		\
+						highlight.y + highlight.z;								\
+						\
+						color0 = (1.0f - highlightSum) * tintColor +			\
+						highlightSum * highlightColor;							\
+						}";
+
+		String psCode = "#version 400\n						\
+						\
+						in vec4 color0;						\
+						out vec4 fragColor;					\
+						\
+						void main()							\
+						{									\
+						fragColor = color0;					\
+						}";
+
+		HHighLevelGpuProgram vsProgram = HighLevelGpuProgram::create(vsCode, "vs_main", "glsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
+		HHighLevelGpuProgram psProgram = HighLevelGpuProgram::create(psCode, "ps_main", "glsl", GPT_FRAGMENT_PROGRAM, GPP_PS_4_0);
+
+		vsProgram.synchronize();
+		psProgram.synchronize();
+
+		mDockDropOverlayShader = Shader::create("DockDropOverlayShader");
+
+		mDockDropOverlayShader->addParameter("invViewportWidth", "invViewportWidth", GPDT_FLOAT1);
+		mDockDropOverlayShader->addParameter("invViewportHeight", "invViewportHeight", GPDT_FLOAT1);
+
+		mDockDropOverlayShader->addParameter("tintColor", "tintColor", GPDT_FLOAT4);
+		mDockDropOverlayShader->addParameter("highlightColor", "highlightColor", GPDT_FLOAT4);
+		mDockDropOverlayShader->addParameter("highlightActive", "highlightActive", GPDT_FLOAT4);
+
+		TechniquePtr newTechnique = mDockDropOverlayShader->addTechnique("GLRenderSystem", RendererManager::getCoreRendererName()); 
+		PassPtr newPass = newTechnique->addPass();
+		newPass->setVertexProgram(vsProgram);
+		newPass->setFragmentProgram(psProgram);
+
+		BLEND_STATE_DESC desc;
+		desc.renderTargetDesc[0].blendEnable = true;
+		desc.renderTargetDesc[0].srcBlend = BF_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].dstBlend = BF_INV_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].blendOp = BO_ADD;
+
+		HBlendState blendState = BlendState::create(desc);
+		newPass->setBlendState(blendState);
+
+		DEPTH_STENCIL_STATE_DESC depthStateDesc;
+		depthStateDesc.depthReadEnable = false;
+		depthStateDesc.depthWriteEnable = false;
+
+		HDepthStencilState depthState = DepthStencilState::create(depthStateDesc);
+		newPass->setDepthStencilState(depthState);
+	}
 }

BansheeForwardRenderer/Source/BsForwardRenderer.cpp

@@ -160,6 +160,13 @@ namespace BansheeEngine
 		DrawHelper3D::instance().render(camera, *mRenderQueue);
 		DrawHelper2D::instance().render(camera, *mRenderQueue);
 
+		// Get any operations from hooked up callbacks
+		const Viewport* viewportRawPtr = camera->getViewport().get();
+		auto callbacksForViewport = mRenderCallbacks[viewportRawPtr];
+
+		for(auto& callback : callbacksForViewport)
+			callback(viewportRawPtr, *mRenderQueue);
+
 		// TODO - Material queue is completely ignored
 		mRenderQueue->sort();
 		const Vector<SortedRenderOp>::type& sortedROps =  mRenderQueue->getSortedRenderOps();

CamelotClient/Include/BsDockManager.h

@@ -43,6 +43,7 @@ namespace BansheeEditor
 		DockManager(BS::GUIWidget* parent);
 		~DockManager();
 
+		void render(const CM::Viewport* viewport, CM::RenderQueue& renderQueue);
 		void insert(EditorWidgetContainer* relativeTo, EditorWidget* widgetToInsert, DockLocation location);
 
 		void setArea(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
@@ -50,5 +51,9 @@ namespace BansheeEditor
 	private:
 		BS::GUIWidget* mParent;
 		DockContainer mRootContainer;
+
+		CM::HMesh mDropOverlayMesh;
+		CM::HMaterial mDropOverlayMat;
+		void createDropOverlayMesh(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
 	};
 }

CamelotClient/Source/BsDockManager.cpp

@@ -2,6 +2,16 @@
 #include "BsEditorWidgetContainer.h"
 #include "CmMath.h"
 #include "CmException.h"
+#include "CmMesh.h"
+#include "CmMaterial.h"
+#include "CmVector2.h"
+#include "CmRenderQueue.h"
+#include "CmApplication.h"
+#include "CmRendererManager.h"
+#include "CmRenderer.h"
+#include "BsBuiltinMaterialManager.h"
+#include "BsGUIWidget.h"
+#include "BsCamera.h"
 
 using namespace CamelotFramework;
 using namespace BansheeEngine;
@@ -151,7 +161,9 @@ namespace BansheeEditor
 	DockManager::DockManager(BS::GUIWidget* parent)
 		:mParent(parent)
 	{
+		mDropOverlayMat = BuiltinMaterialManager::instance().createDockDropOverlayMaterial();
 
+		RendererManager::instance().getActive()->addRenderCallback(parent->getTarget(), boost::bind(&DockManager::render, this, _1, _2));
 	}
 
 	DockManager::~DockManager()
@@ -159,6 +171,27 @@ namespace BansheeEditor
 
 	}
 
+	void DockManager::render(const Viewport* viewport, CM::RenderQueue& renderQueue)
+	{
+		float invViewportWidth = 1.0f / (viewport->getWidth() * 0.5f);
+		float invViewportHeight = 1.0f / (viewport->getHeight() * 0.5f);
+
+		if(mDropOverlayMesh == nullptr || !mDropOverlayMesh.isLoaded() || !mDropOverlayMesh->isInitialized())
+			return;
+
+		if(mDropOverlayMat == nullptr || !mDropOverlayMat.isLoaded() || !mDropOverlayMat->isInitialized())
+			return;
+
+		mDropOverlayMat->setFloat("invViewportWidth", invViewportWidth);
+		mDropOverlayMat->setFloat("invViewportHeight", invViewportHeight);
+
+		mDropOverlayMat->setColor("tintColor", Color::White);
+		mDropOverlayMat->setColor("highlightColor", Color::Green);
+		mDropOverlayMat->setColor("highlightActive", Color(0.0f, 0.0f, 0.0f, 0.0f));
+
+		renderQueue.add(mDropOverlayMat, mDropOverlayMesh->getSubMeshData(), Vector3::ZERO);
+	}
+
 	void DockManager::insert(EditorWidgetContainer* relativeTo, EditorWidget* widgetToInsert, DockLocation location)
 	{
 		if(relativeTo != nullptr)
@@ -195,5 +228,144 @@ namespace BansheeEditor
 	void DockManager::setArea(INT32 x, INT32 y, UINT32 width, UINT32 height)
 	{
 		mRootContainer.setArea(x, y, width, height);
+
+		createDropOverlayMesh(x, y, width, height);
+	}
+
+	void DockManager::createDropOverlayMesh(INT32 x, INT32 y, UINT32 width, UINT32 height)
+	{
+		const static int spacing = 10;
+		const static float innerScale = 0.75f;
+
+		UINT32 outWidth = std::max(0, (INT32)width - spacing * 2);
+		UINT32 outHeight = std::max(0, (INT32)height - spacing * 2);
+		UINT32 inWidth = (UINT32)Math::FloorToInt(innerScale * outWidth);
+		UINT32 inHeight = (UINT32)Math::FloorToInt(innerScale * outHeight);
+		INT32 inXOffset = Math::FloorToInt((outWidth - inWidth) * 0.5f);
+		INT32 inYOffset = Math::FloorToInt((outHeight - inHeight) * 0.5f);
+
+		Vector2 outTopLeft((float)x, (float)y);
+		Vector2 outTopRight((float)(x + outWidth), (float)y);
+		Vector2 outBotLeft((float)x, (float)(y + outHeight));
+		Vector2 outBotRight((float)(x + outWidth), (float)(y + outHeight));
+
+		Vector2 inTopLeft((float)(x + inXOffset), (float)(y + inYOffset));
+		Vector2 inTopRight((float)(x + inXOffset + inWidth), (float)(y + inYOffset));
+		Vector2 inBotLeft((float)(x + inXOffset), (float)(y + inYOffset + inHeight));
+		Vector2 inBotRight((float)(x + inXOffset + inWidth), (float)(y + inYOffset + inHeight));
+
+		MeshDataPtr meshData = cm_shared_ptr<MeshData, ScratchAlloc>(16);
+
+		meshData->beginDesc();
+
+		meshData->addSubMesh(24, 0, DOT_TRIANGLE_LIST);
+		meshData->addVertElem(VET_FLOAT2, VES_POSITION);
+		meshData->addVertElem(VET_COLOR, VES_COLOR);
+
+		meshData->endDesc();
+
+		auto vertIter = meshData->getVec2DataIter(VES_POSITION);
+		auto colIter = meshData->getDWORDDataIter(VES_COLOR);
+
+		// Top
+		Vector2 topOffset((float)spacing, 0.0f);
+
+		Vector2 dbg = outTopLeft + topOffset;
+		vertIter.addValue(outTopLeft + topOffset);
+		vertIter.addValue(outTopRight + topOffset);
+		vertIter.addValue(inTopRight + topOffset);
+		vertIter.addValue(inTopLeft + topOffset);
+
+		Color color(1.0f, 0.0f, 0.0f, 0.0f);
+		UINT32 color32 = color.getAsRGBA();
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+
+		// Bottom
+		Vector2 botOffset((float)spacing, (float)spacing * 2.0f);
+		vertIter.addValue(inBotLeft + botOffset);
+		vertIter.addValue(inBotRight + botOffset);
+		vertIter.addValue(outBotRight + botOffset);
+		vertIter.addValue(outBotLeft + botOffset);
+
+		color = Color(0.0f, 1.0f, 0.0f, 0.0f);
+		color32 = color.getAsRGBA();
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+
+		// Left
+		Vector2 leftOffset(0.0f, (float)spacing);
+		vertIter.addValue(outTopLeft + leftOffset);
+		vertIter.addValue(inTopLeft + leftOffset);
+		vertIter.addValue(inBotLeft + leftOffset);
+		vertIter.addValue(outBotLeft + leftOffset);
+
+		color = Color(0.0f, 0.0f, 1.0f, 0.0f);
+		color32 = color.getAsRGBA();
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+
+		// Right
+		Vector2 rightOffset((float)spacing * 2.0f, (float)spacing);
+		vertIter.addValue(inTopRight + rightOffset);
+		vertIter.addValue(outTopRight + rightOffset);
+		vertIter.addValue(outBotRight + rightOffset);
+		vertIter.addValue(inBotRight + rightOffset);
+
+		color = Color(0.0f, 0.0f, 0.0f, 1.0f);
+		color32 = color.getAsRGBA();
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+		colIter.addValue(color32);
+
+		UINT32* indexData = meshData->getIndices32();
+
+		// Top
+		indexData[0] = 0;
+		indexData[1] = 1;
+		indexData[2] = 2;
+
+		indexData[3] = 0;
+		indexData[4] = 2;
+		indexData[5] = 3;
+
+		// Bottom
+		indexData[6] = 4;
+		indexData[7] = 5;
+		indexData[8] = 6;
+
+		indexData[9] = 4;
+		indexData[10] = 6;
+		indexData[11] = 7;
+
+		// Left
+		indexData[12] = 8;
+		indexData[13] = 9;
+		indexData[14] = 10;
+
+		indexData[15] = 8;
+		indexData[16] = 10;
+		indexData[17] = 11;
+
+		// Right
+		indexData[18] = 12;
+		indexData[19] = 13;
+		indexData[20] = 14;
+
+		indexData[21] = 12;
+		indexData[22] = 14;
+		indexData[23] = 15;
+
+		mDropOverlayMesh = Mesh::create();
+
+		gMainSyncedCA().writeSubresource(mDropOverlayMesh.getInternalPtr(), 0, *meshData);
+		gMainSyncedCA().submitToCoreThread(true);
 	}
 }

CamelotClient/Source/BsMainEditorWindow.cpp

@@ -19,6 +19,11 @@ namespace BansheeEditor
 	MainEditorWindow::MainEditorWindow(CM::RenderWindowPtr renderWindow)
 		:EditorWindowBase(renderWindow), mDockManager(cm_new<DockManager>(mGUI.get()))
 	{
+		UINT32 widgetWidth = (UINT32)std::max(0, (INT32)getWidth() - 2);
+		UINT32 widgetHeight = (UINT32)std::max(0, (INT32)getHeight() - 2);
+
+		mDockManager->setArea(1, 1, widgetWidth, widgetHeight);
+
 		// DEBUG ONLY
 
 		HSceneObject sceneCameraGO = SceneObject::create("SceneCamera");

CamelotCore/CamelotCore.vcxproj

@@ -441,6 +441,7 @@
     <ClCompile Include="Source\CmGpuProgIncludeImporter.cpp" />
     <ClCompile Include="Source\CmPixelData.cpp" />
     <ClCompile Include="Source\CmPixelUtil.cpp" />
+    <ClCompile Include="Source\CmRenderer.cpp" />
     <ClCompile Include="Source\CmRenderQueue.cpp" />
     <ClCompile Include="Source\CmTextureView.cpp" />
     <ClCompile Include="Source\CmTextUtility.cpp" />

CamelotCore/CamelotCore.vcxproj.filters

@@ -722,5 +722,8 @@
     <ClCompile Include="Source\CmRenderQueue.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmRenderer.cpp">
+      <Filter>Source Files\Renderer</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotCore/Include/CmMeshData.h

@@ -155,14 +155,6 @@ namespace CamelotFramework
 		 */
 		VertexElemIter<Vector4> getVec4DataIter(VertexElementSemantic semantic, UINT32 semanticIdx = 0, UINT32 streamIdx = 0);
 
-		/**
-		 * @brief	Returns an iterator you can use for easily retrieving or setting Color vertex elements. This is the preferred
-		 * 			method of assigning or reading vertex data. 
-		 * 			
-		 * @note	If vertex data of this type/semantic/index/stream doesn't exist and exception will be thrown.
-		 */
-		VertexElemIter<Color> getColorDataIter(VertexElementSemantic semantic, UINT32 semanticIdx = 0, UINT32 streamIdx = 0);
-
 		/**
 		 * @brief	Returns an iterator you can use for easily retrieving or setting DWORD vertex elements. This is the preferred
 		 * 			method of assigning or reading vertex data. 

CamelotCore/Include/CmRenderer.h

@@ -2,10 +2,11 @@
 
 #include "CmPrerequisites.h"
 #include "CmGameObject.h"
+#include <boost/signals.hpp>
 
 namespace CamelotFramework
 {
-	class Renderer
+	class CM_EXPORT Renderer
 	{
 	public:
 		virtual const String& getName() const = 0;
@@ -14,5 +15,10 @@ namespace CamelotFramework
 		 * @brief	Renders all cameras.
 		 */
 		virtual void renderAll() = 0;
+
+		void addRenderCallback(const Viewport* viewport, std::function<void(const Viewport*, RenderQueue&)> callback);
+
+	protected:
+		UnorderedMap<const Viewport*, Vector<std::function<void(const Viewport*, RenderQueue&)>>::type>::type mRenderCallbacks;
 	};
 }

CamelotCore/Source/CmMeshData.cpp

@@ -378,15 +378,6 @@ namespace CamelotFramework
 		return VertexElemIter<Vector4>(data, vertexStride, mNumVertices);
 	}
 
-	VertexElemIter<Color> MeshData::getColorDataIter(VertexElementSemantic semantic, UINT32 semanticIdx, UINT32 streamIdx)
-	{
-		UINT8* data;
-		UINT32 vertexStride;
-		getDataForIterator(semantic, semanticIdx, streamIdx, data, vertexStride);
-
-		return VertexElemIter<Color>(data, vertexStride, mNumVertices);
-	}
-
 	VertexElemIter<UINT32> MeshData::getDWORDDataIter(VertexElementSemantic semantic, UINT32 semanticIdx, UINT32 streamIdx)
 	{
 		UINT8* data;

CamelotCore/Source/CmRenderer.cpp

@@ -0,0 +1,9 @@
+#include "CmRenderer.h"
+
+namespace CamelotFramework
+{
+	void Renderer::addRenderCallback(const Viewport* viewport, std::function<void(const Viewport*, RenderQueue&)> callback)
+	{
+		mRenderCallbacks[viewport].push_back(callback);
+	}
+}

CamelotFBXImporter/Source/CmFBXImporter.cpp

@@ -370,9 +370,9 @@ namespace CamelotFramework
 		// Allocate the array memory, by control point or by polygon vertex.
 		VertexElemIter<Vector3> positions = meshData->getVec3DataIter(VES_POSITION);
 
-		VertexElemIter<Color> colors;
+		VertexElemIter<UINT32> colors;
 		if(hasColor)
-			colors = meshData->getColorDataIter(VES_COLOR);
+			colors = meshData->getDWORDDataIter(VES_COLOR);
 
 		VertexElemIter<Vector3> normals;
 		if (hasNormal)
@@ -459,7 +459,8 @@ namespace CamelotFramework
 					curColorValue[2] = static_cast<float>(lCurrentColor[2]);
 					curColorValue[3] = static_cast<float>(lCurrentColor[3]);
 
-					colors.addValue(curColorValue);
+					UINT32 color32 = curColorValue.getAsRGBA();
+					colors.addValue(color32);
 				}
 
 				// Save the normal.
@@ -605,7 +606,8 @@ namespace CamelotFramework
 						curColorValue[2] = static_cast<float>(lCurrentColor[2]);
 						curColorValue[3] = static_cast<float>(lCurrentColor[3]);
 
-						colors.addValue(curColorValue);
+						UINT32 color32 = curColorValue.getAsRGBA();
+						colors.addValue(color32);
 					}
 
 					if (hasNormal)