Refactored renderer utility methods into their own class

BansheeCore/BansheeCore.vcxproj

@@ -309,6 +309,7 @@
     <ClInclude Include="Include\BsPrefabRTTI.h" />
     <ClInclude Include="Include\BsPrefabUtility.h" />
     <ClInclude Include="Include\BsRendererMeshData.h" />
+    <ClInclude Include="Include\BsRendererUtility.h" />
     <ClInclude Include="Include\BsShaderIncludeRTTI.h" />
     <ClInclude Include="Include\BsIResourceListener.h" />
     <ClInclude Include="Include\BsMaterialParam.h" />
@@ -493,6 +494,7 @@
     <ClCompile Include="Source\BsGpuParams.cpp" />
     <ClCompile Include="Source\BsProfilerGPU.cpp" />
     <ClCompile Include="Source\BsRendererMeshData.cpp" />
+    <ClCompile Include="Source\BsRendererUtility.cpp" />
     <ClCompile Include="Source\BsShaderInclude.cpp" />
     <ClCompile Include="Source\BsGpuProgram.cpp" />
     <ClCompile Include="Source\BsGpuResourceData.cpp" />

BansheeCore/BansheeCore.vcxproj.filters

@@ -578,6 +578,9 @@
     <ClInclude Include="Include\BsParamBlocks.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsRendererUtility.h">
+      <Filter>Header Files\Renderer</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsCoreApplication.cpp">
@@ -910,5 +913,8 @@
     <ClCompile Include="Source\Win32\BsWin32Window.cpp">
       <Filter>Source Files\Win32</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsRendererUtility.cpp">
+      <Filter>Source Files\Renderer</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

BansheeCore/Include/BsCoreRenderer.h

@@ -140,23 +140,6 @@ namespace BansheeEngine
 		 */
 		virtual SPtr<CoreRendererOptions> getOptions() const { return SPtr<CoreRendererOptions>(); }
 
-		/**
-		 * @brief	Activates the specified pass on the pipeline.
-		 *
-		 * @param	material	Parent material of the pass.
-		 * @param	passIdx		Index of the pass in the parent material.
-		 *
-		 * @note	Core thread.
-		 */
-		static void setPass(const SPtr<MaterialCore>& material, UINT32 passIdx);
-
-		/**
-		 * @brief	Draws the specified mesh proxy with last set pass.
-		 *
-		 * @note	Core thread.
-		 */
-		static void draw(const SPtr<MeshCoreBase>& mesh, const SubMesh& subMesh);
-
 	protected:
 		UnorderedMap<const CameraCore*, Map<UINT32, std::function<void()>>> mRenderCallbacks;
 	};

BansheeCore/Include/BsRendererUtility.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "BsCorePrerequisites.h"
+#include "BsModule.h"
+
+namespace BansheeEngine
+{
+	/**
+	 * @brief	Contains various utility methods that make various common operations in the renderer easier.
+	 * 			
+	 * @note	Core thread only.
+	 */
+	class BS_CORE_EXPORT RendererUtility : public Module<RendererUtility>
+	{
+	public:
+		RendererUtility();
+		~RendererUtility();
+
+		/**
+		 * @brief	Activates the specified material pass for rendering. Any further draw calls will be executed using 
+		 * 			this pass.
+		 *
+		 * @param	material	Material containing the pass.
+		 * @param	passIdx		Index of the pass in the material.
+		 *
+		 * @note	Core thread.
+		 */
+		void setPass(const SPtr<MaterialCore>& material, UINT32 passIdx);
+
+		/**
+		 * @brief	Draws the specified mesh.
+		 *
+		 * @note	Core thread.
+		 */
+		void draw(const SPtr<MeshCoreBase>& mesh, const SubMesh& subMesh);
+
+		/**
+		 * @brief	Draws a quad over the entire viewport in normalized device coordinates.
+		 * 			
+		 * @note	Core thread.
+		 */
+		void drawScreenQuad(const CameraCore& camera);
+
+	private:
+		SPtr<MeshCore> mFullScreenQuadMesh;
+	};
+
+	/**
+	 * @brief	Provides global access to the renderer utility.
+	 * 			
+	 * @note	Core thread only.
+	 */
+	BS_CORE_EXPORT RendererUtility& gRendererUtility();
+}

BansheeCore/Source/BsCoreRenderer.cpp

@@ -42,129 +42,4 @@ namespace BansheeEngine
 				mRenderCallbacks.erase(iterFind);
 		}
 	}
-
-	void CoreRenderer::setPass(const SPtr<MaterialCore>& material, UINT32 passIdx)
-	{
-		THROW_IF_NOT_CORE_THREAD;
-
-		RenderAPICore& rs = RenderAPICore::instance();
-
-		SPtr<PassCore> pass = material->getPass(passIdx);
-		SPtr<PassParametersCore> passParams = material->getPassParameters(passIdx);
-
-		struct StageData
-		{
-			GpuProgramType type;
-			bool enable;
-			SPtr<GpuParamsCore> params;
-			SPtr<GpuProgramCore> program;
-		};
-
-		const UINT32 numStages = 6;
-		StageData stages[numStages] =
-		{
-			{
-				GPT_VERTEX_PROGRAM, pass->hasVertexProgram(),
-				passParams->mVertParams, pass->getVertexProgram()
-			},
-			{
-				GPT_FRAGMENT_PROGRAM, pass->hasFragmentProgram(),
-				passParams->mFragParams, pass->getFragmentProgram()
-			},
-			{
-				GPT_GEOMETRY_PROGRAM, pass->hasGeometryProgram(),
-				passParams->mGeomParams, pass->getGeometryProgram()
-			},
-			{
-				GPT_HULL_PROGRAM, pass->hasHullProgram(),
-				passParams->mHullParams, pass->getHullProgram()
-			},
-			{
-				GPT_DOMAIN_PROGRAM, pass->hasDomainProgram(),
-				passParams->mDomainParams, pass->getDomainProgram()
-			},
-			{
-				GPT_COMPUTE_PROGRAM, pass->hasComputeProgram(),
-				passParams->mComputeParams, pass->getComputeProgram()
-			}
-		};
-
-		for (UINT32 i = 0; i < numStages; i++)
-		{
-			const StageData& stage = stages[i];
-
-			if (stage.enable)
-			{
-				rs.bindGpuProgram(stage.program);
-				rs.setGpuParams(stage.type, stage.params);
-
-			}
-			else
-				rs.unbindGpuProgram(stage.type);
-		}
-
-		// TODO - Try to limit amount of state changes, if previous state is already the same
-
-		// Set up non-texture related pass settings
-		if (pass->getBlendState() != nullptr)
-			rs.setBlendState(pass->getBlendState());
-		else
-			rs.setBlendState(BlendStateCore::getDefault());
-
-		if (pass->getDepthStencilState() != nullptr)
-			rs.setDepthStencilState(pass->getDepthStencilState(), pass->getStencilRefValue());
-		else
-			rs.setDepthStencilState(DepthStencilStateCore::getDefault(), pass->getStencilRefValue());
-
-		if (pass->getRasterizerState() != nullptr)
-			rs.setRasterizerState(pass->getRasterizerState());
-		else
-			rs.setRasterizerState(RasterizerStateCore::getDefault());
-	}
-
-	void CoreRenderer::draw(const SPtr<MeshCoreBase>& mesh, const SubMesh& subMesh)
-	{
-		THROW_IF_NOT_CORE_THREAD;
-
-		RenderAPICore& rs = RenderAPICore::instance();
-		const MeshProperties& meshProps = mesh->getProperties();
-		std::shared_ptr<VertexData> vertexData = mesh->getVertexData();
-
-		rs.setVertexDeclaration(vertexData->vertexDeclaration);
-		auto& vertexBuffers = vertexData->getBuffers();
-
-		if (vertexBuffers.size() > 0)
-		{
-			SPtr<VertexBufferCore> buffers[MAX_BOUND_VERTEX_BUFFERS];
-
-			UINT32 endSlot = 0;
-			UINT32 startSlot = MAX_BOUND_VERTEX_BUFFERS;
-			for (auto iter = vertexBuffers.begin(); iter != vertexBuffers.end(); ++iter)
-			{
-				if (iter->first >= MAX_BOUND_VERTEX_BUFFERS)
-					BS_EXCEPT(InvalidParametersException, "Buffer index out of range");
-
-				startSlot = std::min(iter->first, startSlot);
-				endSlot = std::max(iter->first, endSlot);
-			}
-
-			for (auto iter = vertexBuffers.begin(); iter != vertexBuffers.end(); ++iter)
-			{
-				buffers[iter->first - startSlot] = iter->second;
-			}
-
-			rs.setVertexBuffers(startSlot, buffers, endSlot - startSlot + 1);
-		}
-
-		rs.setDrawOperation(subMesh.drawOp);
-
-		SPtr<IndexBufferCore> indexBuffer = mesh->getIndexBuffer();
-
-		UINT32 indexCount = subMesh.indexCount;
-
-		rs.setIndexBuffer(indexBuffer);
-		rs.drawIndexed(subMesh.indexOffset + mesh->getIndexOffset(), indexCount, mesh->getVertexOffset(), vertexData->vertexCount);
-
-		mesh->_notifyUsedOnGPU();
-	}
 }

BansheeCore/Source/BsRendererUtility.cpp

@@ -0,0 +1,180 @@
+#include "BsRendererUtility.h"
+#include "BsRenderAPI.h"
+#include "BsMesh.h"
+#include "BsVertexDataDesc.h"
+#include "BsMaterial.h"
+#include "BsPass.h"
+#include "BsBlendState.h"
+#include "BsDepthStencilState.h"
+#include "BsRasterizerState.h"
+
+namespace BansheeEngine
+{
+	RendererUtility::RendererUtility()
+	{
+		VertexDataDescPtr vertexDesc = bs_shared_ptr_new<VertexDataDesc>();
+		vertexDesc->addVertElem(VET_FLOAT3, VES_POSITION);
+
+		MeshDataPtr meshData = bs_shared_ptr_new<MeshData>(4, 6, vertexDesc);
+
+		auto vecIter = meshData->getVec3DataIter(VES_POSITION);
+		vecIter.setValue(Vector3(-1.0f, 1.0, 0));
+		vecIter.setValue(Vector3(1.0f, 1.0f, 0));
+		vecIter.setValue(Vector3(-1.0f, -1.0f, 0));
+		vecIter.setValue(Vector3(1.0f, -1.0f, 0));
+
+		auto indices = meshData->getIndices32();
+		indices[0] = 0;
+		indices[1] = 1;
+		indices[2] = 2;
+		indices[3] = 1;
+		indices[4] = 3;
+		indices[5] = 2;
+
+		mFullScreenQuadMesh = MeshCore::create(meshData);
+	}
+
+	RendererUtility::~RendererUtility()
+	{
+		
+	}
+
+	void RendererUtility::setPass(const SPtr<MaterialCore>& material, UINT32 passIdx)
+	{
+		RenderAPICore& rs = RenderAPICore::instance();
+
+		SPtr<PassCore> pass = material->getPass(passIdx);
+		SPtr<PassParametersCore> passParams = material->getPassParameters(passIdx);
+
+		struct StageData
+		{
+			GpuProgramType type;
+			bool enable;
+			SPtr<GpuParamsCore> params;
+			SPtr<GpuProgramCore> program;
+		};
+
+		const UINT32 numStages = 6;
+		StageData stages[numStages] =
+		{
+			{
+				GPT_VERTEX_PROGRAM, pass->hasVertexProgram(),
+				passParams->mVertParams, pass->getVertexProgram()
+			},
+			{
+				GPT_FRAGMENT_PROGRAM, pass->hasFragmentProgram(),
+				passParams->mFragParams, pass->getFragmentProgram()
+			},
+			{
+				GPT_GEOMETRY_PROGRAM, pass->hasGeometryProgram(),
+				passParams->mGeomParams, pass->getGeometryProgram()
+			},
+			{
+				GPT_HULL_PROGRAM, pass->hasHullProgram(),
+				passParams->mHullParams, pass->getHullProgram()
+			},
+			{
+				GPT_DOMAIN_PROGRAM, pass->hasDomainProgram(),
+				passParams->mDomainParams, pass->getDomainProgram()
+			},
+			{
+				GPT_COMPUTE_PROGRAM, pass->hasComputeProgram(),
+				passParams->mComputeParams, pass->getComputeProgram()
+			}
+		};
+
+		for (UINT32 i = 0; i < numStages; i++)
+		{
+			const StageData& stage = stages[i];
+
+			if (stage.enable)
+			{
+				rs.bindGpuProgram(stage.program);
+				rs.setGpuParams(stage.type, stage.params);
+
+			}
+			else
+				rs.unbindGpuProgram(stage.type);
+		}
+
+		// Set up non-texture related pass settings
+		if (pass->getBlendState() != nullptr)
+			rs.setBlendState(pass->getBlendState());
+		else
+			rs.setBlendState(BlendStateCore::getDefault());
+
+		if (pass->getDepthStencilState() != nullptr)
+			rs.setDepthStencilState(pass->getDepthStencilState(), pass->getStencilRefValue());
+		else
+			rs.setDepthStencilState(DepthStencilStateCore::getDefault(), pass->getStencilRefValue());
+
+		if (pass->getRasterizerState() != nullptr)
+			rs.setRasterizerState(pass->getRasterizerState());
+		else
+			rs.setRasterizerState(RasterizerStateCore::getDefault());
+	}
+
+	void RendererUtility::draw(const SPtr<MeshCoreBase>& mesh, const SubMesh& subMesh)
+	{
+		RenderAPICore& rs = RenderAPICore::instance();
+		const MeshProperties& meshProps = mesh->getProperties();
+		std::shared_ptr<VertexData> vertexData = mesh->getVertexData();
+
+		rs.setVertexDeclaration(vertexData->vertexDeclaration);
+		auto& vertexBuffers = vertexData->getBuffers();
+
+		if (vertexBuffers.size() > 0)
+		{
+			SPtr<VertexBufferCore> buffers[MAX_BOUND_VERTEX_BUFFERS];
+
+			UINT32 endSlot = 0;
+			UINT32 startSlot = MAX_BOUND_VERTEX_BUFFERS;
+			for (auto iter = vertexBuffers.begin(); iter != vertexBuffers.end(); ++iter)
+			{
+				if (iter->first >= MAX_BOUND_VERTEX_BUFFERS)
+					BS_EXCEPT(InvalidParametersException, "Buffer index out of range");
+
+				startSlot = std::min(iter->first, startSlot);
+				endSlot = std::max(iter->first, endSlot);
+			}
+
+			for (auto iter = vertexBuffers.begin(); iter != vertexBuffers.end(); ++iter)
+			{
+				buffers[iter->first - startSlot] = iter->second;
+			}
+
+			rs.setVertexBuffers(startSlot, buffers, endSlot - startSlot + 1);
+		}
+
+		rs.setDrawOperation(subMesh.drawOp);
+
+		SPtr<IndexBufferCore> indexBuffer = mesh->getIndexBuffer();
+
+		UINT32 indexCount = subMesh.indexCount;
+
+		rs.setIndexBuffer(indexBuffer);
+		rs.drawIndexed(subMesh.indexOffset + mesh->getIndexOffset(), indexCount, mesh->getVertexOffset(), vertexData->vertexCount);
+
+		mesh->_notifyUsedOnGPU();
+	}
+
+	void RendererUtility::drawScreenQuad(const CameraCore& camera)
+	{
+		// Note: Consider drawing the quad using a single large triangle for possibly better performance
+		Vector3 vertices[4];
+
+		// TODO - Set up vertices
+
+
+		SPtr<VertexBufferCore> vb = mFullScreenQuadMesh->getVertexData()->getBuffer(0);
+		vb->writeData(0, sizeof(vertices), vertices, BufferWriteType::Discard);
+
+		RenderAPICore& rapi = RenderAPICore::instance();
+		draw(mFullScreenQuadMesh, mFullScreenQuadMesh->getProperties().getSubMesh());
+	}
+
+	RendererUtility& gRendererUtility()
+	{
+		return RendererUtility::instance();
+	}
+}

BansheeEditor/Source/BsDockManager.cpp

@@ -24,6 +24,7 @@
 #include "BsEditorWindow.h"
 #include "BsGUIPanel.h"
 #include "BsCoreThread.h"
+#include "BsRendererUtility.h"
 #include "BsGUISkin.h"
 #include "BsGUIButton.h"
 #include <BsSelectionRenderer.h>
@@ -1207,7 +1208,7 @@ namespace BansheeEngine
 
 		mMaterial->setColor("highlightActive", highlightColor);
 
-		CoreRenderer::setPass(mMaterial, 0);
-		CoreRenderer::draw(mMesh, mMesh->getProperties().getSubMesh(0));
+		gRendererUtility().setPass(mMaterial, 0);
+		gRendererUtility().draw(mMesh, mMesh->getProperties().getSubMesh(0));
 	}
 }

BansheeEditor/Source/BsGizmoManager.cpp

@@ -13,6 +13,7 @@
 #include "BsGpuParams.h"
 #include "BsRenderAPI.h"
 #include "BsCoreRenderer.h"
+#include "BsRendererUtility.h"
 #include "BsTransientMesh.h"
 #include "BsRendererManager.h"
 #include "BsDrawHelper.h"
@@ -774,19 +775,19 @@ namespace BansheeEngine
 		case GizmoManager::GizmoMaterial::Solid:
 			mSolidMaterial.mViewProj.set(viewProjMat);
 			mSolidMaterial.mViewDir.set((Vector4)viewDir);
-			CoreRenderer::setPass(mSolidMaterial.mat, 0);
+			gRendererUtility().setPass(mSolidMaterial.mat, 0);
 			break;
 		case GizmoManager::GizmoMaterial::Wire:
 			mWireMaterial.mViewProj.set(viewProjMat);
-			CoreRenderer::setPass(mWireMaterial.mat, 0);
+			gRendererUtility().setPass(mWireMaterial.mat, 0);
 			break;
 		case GizmoManager::GizmoMaterial::Picking:
 			mPickingMaterial.mViewProj.set(viewProjMat);
-			CoreRenderer::setPass(mPickingMaterial.mat, 0);
+			gRendererUtility().setPass(mPickingMaterial.mat, 0);
 			break;
 		}
 		
-		CoreRenderer::draw(mesh, mesh->getProperties().getSubMesh(0));
+		gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
 	}
 
 	void GizmoManagerCore::renderIconGizmos(Rect2I screenArea, SPtr<MeshCoreBase> mesh, GizmoManager::IconRenderDataVecPtr renderData, bool usePickingMaterial)
@@ -830,7 +831,7 @@ namespace BansheeEngine
 
 			for (UINT32 passIdx = 0; passIdx < 2; passIdx++)
 			{
-				CoreRenderer::setPass(mIconMaterial.mat, passIdx);
+				gRendererUtility().setPass(mIconMaterial.mat, passIdx);
 
 				UINT32 curIndexOffset = mesh->getIndexOffset();
 				for (auto curRenderData : *renderData)
@@ -847,7 +848,7 @@ namespace BansheeEngine
 		{
 			mAlphaPickingMaterial.mViewProj.set(projMat);
 
-			CoreRenderer::setPass(mAlphaPickingMaterial.mat, 0);
+			gRendererUtility().setPass(mAlphaPickingMaterial.mat, 0);
 
 			UINT32 curIndexOffset = 0;
 			for (auto curRenderData : *renderData)

BansheeEditor/Source/BsHandleDrawManager.cpp

@@ -7,6 +7,7 @@
 #include "BsCoreRenderer.h"
 #include "BsTransientMesh.h"
 #include "BsCamera.h"
+#include "BsRendererUtility.h"
 #include "BsSceneObject.h"
 
 using namespace std::placeholders;
@@ -256,9 +257,9 @@ namespace BansheeEngine
 			currentType = mMeshes[0].type;
 
 			if (currentType == MeshType::Solid)
-				CoreRenderer::setPass(mSolidMaterial.mat, 0);
+				gRendererUtility().setPass(mSolidMaterial.mat, 0);
 			else
-				CoreRenderer::setPass(mWireMaterial.mat, 0);
+				gRendererUtility().setPass(mWireMaterial.mat, 0);
 		}
 
 		for (auto& meshData : mMeshes)
@@ -266,14 +267,14 @@ namespace BansheeEngine
 			if (currentType != meshData.type)
 			{
 				if (meshData.type == MeshType::Solid)
-					CoreRenderer::setPass(mSolidMaterial.mat, 0);
+					gRendererUtility().setPass(mSolidMaterial.mat, 0);
 				else
-					CoreRenderer::setPass(mWireMaterial.mat, 0);
+					gRendererUtility().setPass(mWireMaterial.mat, 0);
 
 				currentType = meshData.type;
 			}
 
-			CoreRenderer::draw(meshData.mesh, meshData.mesh->getProperties().getSubMesh(0));
+			gRendererUtility().draw(meshData.mesh, meshData.mesh->getProperties().getSubMesh(0));
 		}
 	}
 }

BansheeEditor/Source/BsSceneGrid.cpp

@@ -11,6 +11,7 @@
 #include "BsEditorSettings.h"
 #include "BsRendererManager.h"
 #include "BsRenderer.h"
+#include "BsRendererUtility.h"
 
 namespace BansheeEngine
 {
@@ -174,7 +175,7 @@ namespace BansheeEngine
 		mGridFadeOutStartParam.set(FADE_OUT_START);
 		mGridFadeOutEndParam.set(FADE_OUT_END);
 
-		CoreRenderer::setPass(mGridMaterial, 0);
-		CoreRenderer::draw(mGridMesh, mGridMesh->getProperties().getSubMesh(0));
+		gRendererUtility().setPass(mGridMaterial, 0);
+		gRendererUtility().draw(mGridMesh, mGridMesh->getProperties().getSubMesh(0));
 	}
 }

BansheeEditor/Source/BsScenePicking.cpp

@@ -23,6 +23,7 @@
 #include "BsShader.h"
 #include "BsCoreRenderer.h"
 #include "BsGizmoManager.h"
+#include "BsRendererUtility.h"
 
 using namespace std::placeholders;
 
@@ -264,7 +265,7 @@ namespace BansheeEngine
 		rs.clearRenderTarget(FBT_COLOR | FBT_DEPTH | FBT_STENCIL, Color::White);
 		rs.setScissorRect(position.x, position.y, position.x + area.x, position.y + area.y);
 
-		CoreRenderer::setPass(mMaterialData[0].mMatPickingCore, 0);
+		gRendererUtility().setPass(mMaterialData[0].mMatPickingCore, 0);
 		bool activeMaterialIsAlpha = false;
 		CullingMode activeMaterialCull = (CullingMode)0;
 
@@ -276,9 +277,9 @@ namespace BansheeEngine
 				activeMaterialCull = renderable.cullMode;
 
 				if (activeMaterialIsAlpha)
-					CoreRenderer::setPass(mMaterialData[(UINT32)activeMaterialCull].mMatPickingAlphaCore, 0);
+					gRendererUtility().setPass(mMaterialData[(UINT32)activeMaterialCull].mMatPickingAlphaCore, 0);
 				else
-					CoreRenderer::setPass(mMaterialData[(UINT32)activeMaterialCull].mMatPickingCore, 0);
+					gRendererUtility().setPass(mMaterialData[(UINT32)activeMaterialCull].mMatPickingCore, 0);
 			}
 
 			Color color = ScenePicking::encodeIndex(renderable.index);
@@ -302,7 +303,7 @@ namespace BansheeEngine
 				rs.setGpuParams(GPT_FRAGMENT_PROGRAM, md.mParamPickingFragParams);
 			}
 
-			CoreRenderer::draw(renderable.mesh, renderable.mesh->getProperties().getSubMesh(0));
+			gRendererUtility().draw(renderable.mesh, renderable.mesh->getProperties().getSubMesh(0));
 		}
 	}
 

BansheeEditor/Source/BsSelectionRenderer.cpp

@@ -14,6 +14,7 @@
 #include "BsCRenderable.h"
 #include "BsRenderable.h"
 #include "BsSceneManager.h"
+#include "BsRendererUtility.h"
 
 using namespace std::placeholders;
 
@@ -131,8 +132,8 @@ namespace BansheeEngine
 			mMatWorldViewProj.set(worldViewProjMat);
 			mColor.set(SELECTION_COLOR);
 
-			CoreRenderer::setPass(mMaterial, 0);
-			CoreRenderer::draw(objData.mesh, objData.mesh->getProperties().getSubMesh(0));
+			gRendererUtility().setPass(mMaterial, 0);
+			gRendererUtility().draw(objData.mesh, objData.mesh->getProperties().getSubMesh(0));
 		}
 	}
 }

BansheeEngine/Source/BsGUIManager.cpp

@@ -35,6 +35,7 @@
 #include "BsRendererManager.h"
 #include "BsRenderer.h"
 #include "BsCamera.h"
+#include "BsRendererUtility.h"
 
 using namespace std::placeholders;
 
@@ -1696,8 +1697,8 @@ namespace BansheeEngine
 			// TODO - I shouldn't be re-applying the entire material for each entry, instead just check which programs
 			// changed, and apply only those + the modified constant buffers and/or texture.
 
-			CoreRenderer::setPass(entry.material, 0);
-			CoreRenderer::draw(entry.mesh, entry.mesh->getProperties().getSubMesh(0));
+			gRendererUtility().setPass(entry.material, 0);
+			gRendererUtility().draw(entry.mesh, entry.mesh->getProperties().getSubMesh(0));
 		}
 	}
 }

RenderBeast/Source/BsRenderBeast.cpp

@@ -33,6 +33,7 @@
 #include "BsLight.h"
 #include "BsRenderTexturePool.h"
 #include "BsRenderTargets.h"
+#include "BsRendererUtility.h"
 
 using namespace std::placeholders;
 
@@ -68,6 +69,8 @@ namespace BansheeEngine
 
 	void RenderBeast::initializeCore()
 	{
+		RendererUtility::startUp();
+
 		mCoreOptions = bs_shared_ptr_new<RenderBeastOptions>();
 		mStaticHandler = bs_new<StaticRenderableHandler>();
 
@@ -95,6 +98,8 @@ namespace BansheeEngine
 		bs_delete(mPointLightMat);
 		bs_delete(mDirLightMat);
 
+		RendererUtility::shutDown();
+
 		assert(mSamplerOverrides.empty());
 	}
 
@@ -544,7 +549,7 @@ namespace BansheeEngine
 				else
 					setPassParams(passParams, nullptr);
 
-				draw(iter->renderElem->mesh, iter->renderElem->subMesh);
+				gRendererUtility().draw(iter->renderElem->mesh, iter->renderElem->subMesh);
 			}
 		}
 		else
@@ -602,7 +607,7 @@ namespace BansheeEngine
 				mDirLightMat->setParameters(light.internal);
 
 				SPtr<MeshCore> mesh = nullptr; // TODO - Get full screen quad
-				draw(mesh, mesh->getProperties().getSubMesh(0));
+				gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
 			}
 
 			// TODO - Cull lights based on visibility, right now I just iterate over all of them. 
@@ -614,7 +619,7 @@ namespace BansheeEngine
 				mPointLightMat->setParameters(light.internal);
 
 				SPtr<MeshCore> mesh = light.internal->getMesh();
-				draw(mesh, mesh->getProperties().getSubMesh(0));
+				gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
 			}
 
 			// TODO - Resolve to render target (Later: Manual resolve during deferred light pass?)
@@ -649,7 +654,7 @@ namespace BansheeEngine
 			else
 				setPassParams(passParams, nullptr);
 
-			draw(iter->renderElem->mesh, iter->renderElem->subMesh);
+			gRendererUtility().draw(iter->renderElem->mesh, iter->renderElem->subMesh);
 		}
 
 		camData.opaqueQueue->clear();
@@ -724,7 +729,7 @@ namespace BansheeEngine
 					setPassParams(passParams, nullptr);
 			}
 
-			draw(iter->renderElem->mesh, iter->renderElem->subMesh);
+			gRendererUtility().draw(iter->renderElem->mesh, iter->renderElem->subMesh);
 		}
 
 		// Render transparent
@@ -754,7 +759,7 @@ namespace BansheeEngine
 			else
 				setPassParams(passParams, nullptr);
 
-			draw(iter->renderElem->mesh, iter->renderElem->subMesh);
+			gRendererUtility().draw(iter->renderElem->mesh, iter->renderElem->subMesh);
 		}
 
 		cameraData.opaqueQueue->clear();

TODOExperimentation.txt

@@ -13,15 +13,10 @@ Assign ViewOrigin, PreViewTranslation, TransViewProj
  - Perhaps do all these modifcations outside of shader (i.e. have the world matrix be pre-transformed)
  - Do this after I have basic rendering working, to avoid additional issues when I'm initially trying to get it to work
  
-Tomorrow:
- - Extend PerCamera buffer with new values required by deferred shaders and generate those parameters in C++
-
 Next week:
- - Deferred base and light passes use different PerCamera buffers, unify them (both in shader and in code)
  - Need to generate a full screen quad for directional light pass (RenderBeast::drawFullscreen(Camera, Material))
    - Consider drawing a large triangle instead of a quad to improve rasterization (probably just add a TODO, and do it when I can test performance)
  - Finish up DefferedPointLightPass by generating cone geometry in shader
- - Generate C++ code for populating cbuffers for deferred shaders (2+ days)
  - Modify Light so it generated adequate number of vertices required for cone geometry, without actually creating the cone
  - Think about how to handle post-processing shaders (HDR tone mapping)
  - Add cube and 3D support for render texture pool