Postprocessing WIP

Documentation/GitHub/install.md

@@ -1,7 +1,7 @@
-# Install
+# Binaries
 
 Banshee is still in development and does not yet come with a proper installer. You will need to extract the downloaded files manually. The platform support is currently limited to Windows only, but more platforms are coming in near future.
 
 The version below is the latest one, check the git releases tags for links for older ones.
 
-[Download binaries (Windows x64)] (http://bearishsun.thalassa.feralhosting.com/Banshee_Win_x64_v0.3.0.zip)
+[Download editor binaries (Windows x64)] (http://bearishsun.thalassa.feralhosting.com/Banshee_Win_x64_v0.3.0.zip)

Source/BansheeCore/Source/BsPass.cpp

@@ -26,6 +26,7 @@ namespace BansheeEngine
 		output.hullProgram = input.hullProgram != nullptr ? input.hullProgram->getCore() : nullptr;
 		output.domainProgram = input.domainProgram != nullptr ? input.domainProgram->getCore() : nullptr;
 		output.hullProgram = input.hullProgram != nullptr ? input.hullProgram->getCore() : nullptr;
+		output.computeProgram = input.computeProgram != nullptr ? input.computeProgram->getCore() : nullptr;
 	}
 
 	template<bool Core>

Source/BansheeD3D11RenderAPI/Include/BsD3D11RenderTexture.h

@@ -26,7 +26,7 @@ namespace BansheeEngine
 		virtual ~D3D11RenderTextureCore() { }
 
 		/** @copydoc RenderTextureCore::getCustomAttribute */
-		void getCustomAttribute(const String& name, void* pData) const override;
+		void getCustomAttribute(const String& name, void* data) const override;
 
 	protected:
 		/** @copydoc RenderTextureCore::getProperties */

Source/BansheeD3D11RenderAPI/Source/BsD3D11HLSLParamParser.cpp

@@ -146,9 +146,35 @@ namespace BansheeEngine
 					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
 					break;
 				case D3D11_SIT_UAV_RWTYPED:
-					memberDesc.type = GPOT_RWTYPED_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+				{
+					switch (resourceDesc.Dimension)
+					{
+					case D3D_SRV_DIMENSION_TEXTURE1D:
+						memberDesc.type = GPOT_TEXTURE1D;
+						desc.textures.insert(std::make_pair(memberDesc.name, memberDesc));
+						break;
+					case D3D_SRV_DIMENSION_TEXTURE2D:
+						memberDesc.type = GPOT_TEXTURE2D;
+						desc.textures.insert(std::make_pair(memberDesc.name, memberDesc));
+						break;
+					case D3D_SRV_DIMENSION_TEXTURE3D:
+						memberDesc.type = GPOT_TEXTURE3D;
+						desc.textures.insert(std::make_pair(memberDesc.name, memberDesc));
+						break;
+					case D3D_SRV_DIMENSION_TEXTURECUBE:
+						memberDesc.type = GPOT_TEXTURECUBE;
+						desc.textures.insert(std::make_pair(memberDesc.name, memberDesc));
+						break;
+					case D3D_SRV_DIMENSION_BUFFER:
+						memberDesc.type = GPOT_RWTYPED_BUFFER;
+						desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+						break;
+					default:
+						LOGWRN("Skipping typed UAV because it has unsupported dimension: " + toString(resourceDesc.Dimension));
+					}
+
 					break;
+				}
 				case D3D11_SIT_UAV_RWSTRUCTURED:
 					memberDesc.type = GPOT_RWSTRUCTURED_BUFFER;
 					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderTexture.cpp

@@ -11,29 +11,33 @@ namespace BansheeEngine
 
 	}
 
-	void D3D11RenderTextureCore::getCustomAttribute(const String& name, void* pData) const
+	void D3D11RenderTextureCore::getCustomAttribute(const String& name, void* data) const
 	{
 		if(name == "RTV")
 		{
-			ID3D11RenderTargetView** pRTVs = (ID3D11RenderTargetView **)pData;			
+			ID3D11RenderTargetView** rtvs = (ID3D11RenderTargetView **)data;			
 			D3D11TextureView* textureView = static_cast<D3D11TextureView*>(mColorSurface.get());
-			*pRTVs = textureView->getRTV();		
-
-			return;
+			*rtvs = textureView->getRTV();		
 		}
 		else if(name == "DSV")
 		{
-			ID3D11DepthStencilView** pDSV = (ID3D11DepthStencilView **)pData;
+			if (mDepthStencilSurface == nullptr)
+				return;
+
+			ID3D11DepthStencilView** dsv = (ID3D11DepthStencilView **)data;
 			D3D11TextureView* depthStencilView = static_cast<D3D11TextureView*>(mDepthStencilSurface.get());
-			*pDSV = depthStencilView->getDSV(false);
-			return;
+
+			*dsv = depthStencilView->getDSV(false);
 		}
 		else if (name == "RODSV")
 		{
-			ID3D11DepthStencilView** pDSV = (ID3D11DepthStencilView **)pData;
+			if (mDepthStencilSurface == nullptr)
+				return;
+
+			ID3D11DepthStencilView** dsv = (ID3D11DepthStencilView **)data;
 			D3D11TextureView* depthStencilView = static_cast<D3D11TextureView*>(mDepthStencilSurface.get());
-			*pDSV = depthStencilView->getDSV(true);
-			return;
+
+			*dsv = depthStencilView->getDSV(true);
 		}
 	}
 

Source/BansheeD3D9RenderAPI/Include/BsD3D9RenderTexture.h

@@ -27,7 +27,7 @@ namespace BansheeEngine
 		virtual ~D3D9RenderTextureCore();
 
 		/** @copydoc RenderTextureCore::getCustomAttribute */
-		void getCustomAttribute(const String& name, void* pData) const override;
+		void getCustomAttribute(const String& name, void* data) const override;
 
 		/** @copydoc D3D9Resource::notifyOnDeviceCreate */
 		void notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device) override;

Source/BansheeD3D9RenderAPI/Source/BsD3D9RenderTexture.cpp

@@ -43,25 +43,22 @@ namespace BansheeEngine
 		mDX9DepthStencilSurface = nullptr;
 	}
 
-	void D3D9RenderTextureCore::getCustomAttribute(const String& name, void* pData) const
+	void D3D9RenderTextureCore::getCustomAttribute(const String& name, void* data) const
 	{
 		if(name == "DDBACKBUFFER")
 		{
-			IDirect3DSurface9 ** pSurf = (IDirect3DSurface9 **)pData;
-			*pSurf = mDX9ColorSurface;
-			return;
+			IDirect3DSurface9** surf = (IDirect3DSurface9**)data;
+			*surf = mDX9ColorSurface;
 		}
 		else if(name == "D3DZBUFFER")
 		{
-			IDirect3DSurface9 ** pSurf = (IDirect3DSurface9 **)pData;
-			*pSurf = mDX9DepthStencilSurface;
-			return;
+			IDirect3DSurface9** surf = (IDirect3DSurface9**)data;
+			*surf = mDX9DepthStencilSurface;
 		}
 		else if(name == "HWND")
 		{
-			HWND *pHwnd = (HWND*)pData;
-			*pHwnd = NULL;
-			return;
+			HWND* hWnd = (HWND*)data;
+			*hWnd = nullptr;
 		}
 	}
 

Source/BansheeEngine/Include/BsRendererUtility.h

@@ -37,7 +37,17 @@ namespace BansheeEngine
 		 *
 		 * @note	Core thread.
 		 */
-		void setPass(const SPtr<MaterialCore>& material, UINT32 passIdx);
+		void setPass(const SPtr<MaterialCore>& material, UINT32 passIdx = 0);
+
+		/**
+		 * Activates the specified material pass for compute. Any further dispatch calls will be executed using this pass.
+		 *
+		 * @param[in]	material	Material containing the pass.
+		 * @param[in]	passIdx		Index of the pass in the material.
+		 *
+		 * @note	Core thread.
+		 */
+		void setComputePass(const SPtr<MaterialCore>& material, UINT32 passIdx = 0);
 
 		/**
 		 * Sets parameters (textures, samplers, buffers) for the currently active pass.

Source/BansheeEngine/Source/BsRendererUtility.cpp

@@ -129,7 +129,7 @@ namespace BansheeEngine
 			SPtr<GpuProgramCore> program;
 		};
 
-		const UINT32 numStages = 6;
+		const UINT32 numStages = 5;
 		StageData stages[numStages] =
 		{
 			{
@@ -151,10 +151,6 @@ namespace BansheeEngine
 			{
 				GPT_DOMAIN_PROGRAM, pass->hasDomainProgram(),
 				passParams->mDomainParams, pass->getDomainProgram()
-			},
-			{
-				GPT_COMPUTE_PROGRAM, pass->hasComputeProgram(),
-				passParams->mComputeParams, pass->getComputeProgram()
 			}
 		};
 
@@ -189,6 +185,22 @@ namespace BansheeEngine
 			rs.setRasterizerState(RasterizerStateCore::getDefault());
 	}
 
+	void RendererUtility::setComputePass(const SPtr<MaterialCore>& material, UINT32 passIdx)
+	{
+		RenderAPICore& rs = RenderAPICore::instance();
+
+		SPtr<PassCore> pass = material->getPass(passIdx);
+		SPtr<PassParametersCore> passParams = material->getPassParameters(passIdx);
+
+		if(pass->hasComputeProgram())
+		{
+			rs.bindGpuProgram(pass->getComputeProgram());
+			rs.setGpuParams(GPT_COMPUTE_PROGRAM, passParams->mComputeParams);
+		}
+		else
+			rs.unbindGpuProgram(GPT_COMPUTE_PROGRAM);
+	}
+
 	void RendererUtility::setPassParams(const SPtr<MaterialCore>& material, UINT32 passIdx)
 	{
 		const SPtr<PassParametersCore>& passParams = material->getPassParameters(passIdx);

Source/BansheeGLRenderAPI/Include/BsGLRenderTexture.h

@@ -29,7 +29,7 @@ namespace BansheeEngine
 		virtual ~GLRenderTextureCore();
 
 		/** @copydoc RenderTextureCore::getCustomAttribute */
-		virtual void getCustomAttribute(const String& name, void* pData) const override;
+		virtual void getCustomAttribute(const String& name, void* data) const override;
 
 	protected:
 		friend class GLRenderTexture;

Source/BansheeGLRenderAPI/Source/BsGLRenderTexture.cpp

@@ -69,15 +69,15 @@ namespace BansheeEngine
 		mFB->bindDepthStencil(depthStencilBuffer);
 	}
 
-	void GLRenderTextureCore::getCustomAttribute(const String& name, void* pData) const
+	void GLRenderTextureCore::getCustomAttribute(const String& name, void* data) const
 	{
 		if(name=="FBO")
 		{
-			*static_cast<GLFrameBufferObject **>(pData) = mFB;
+			*static_cast<GLFrameBufferObject**>(data) = mFB;
 		}
 		else if (name == "GL_FBOID" || name == "GL_MULTISAMPLEFBOID")
 		{
-			*static_cast<GLuint*>(pData) = mFB->getGLFBOID();
+			*static_cast<GLuint*>(data) = mFB->getGLFBOID();
 		}
 	}
 

Source/BansheeSL/Source/BsSLFXCompiler.cpp

@@ -1033,6 +1033,7 @@ namespace BansheeEngine
 				passData->geometryCode = techniqueData.commonPassData.geometryCode + passData->geometryCode;
 				passData->hullCode = techniqueData.commonPassData.hullCode + passData->hullCode;
 				passData->domainCode = techniqueData.commonPassData.domainCode + passData->domainCode;
+				passData->computeCode = techniqueData.commonPassData.computeCode + passData->computeCode;
 				passData->commonCode = techniqueData.commonPassData.commonCode + passData->commonCode;
 				
 				parsePass(passNode, codeBlocks, *passData);

Source/RenderBeast/Include/BsPostProcessing.h

@@ -191,6 +191,22 @@ namespace BansheeEngine
 		MaterialParamTextureCore mReducedHistogramTex;
 	};
 
+	/** Shader that applies tonemapping and converts a HDR image into a LDR image. */
+	class TonemappingMat : public RendererMaterial<TonemappingMat>
+	{
+		RMAT_DEF("PPTonemapping.bsl");
+
+	public:
+		TonemappingMat();
+
+		/** Executes the post-process effect with the provided parameters. */
+		void execute(const SPtr<RenderTextureCore>& sceneColor, const SPtr<ViewportCore>& outputViewport,
+			PostProcessInfo& ppInfo);
+	private:
+		MaterialParamTextureCore mInputTex;
+		MaterialParamTextureCore mEyeAdaptationTex;
+	};
+
 	/**
 	 * Renders post-processing effects for the provided render target.
 	 *
@@ -200,13 +216,15 @@ namespace BansheeEngine
 	{
 	public:
 		/** Renders post-processing effects for the provided render target. */
-		void postProcess(const SPtr<RenderTextureCore>& target, PostProcessInfo& ppInfo, float frameDelta);
+		void postProcess(const SPtr<RenderTextureCore>& sceneColor, const SPtr<ViewportCore>& outputViewport,
+			PostProcessInfo& ppInfo, float frameDelta);
 		
 	private:
 		DownsampleMat mDownsample;
 		EyeAdaptHistogramMat mEyeAdaptHistogram;
 		EyeAdaptHistogramReduceMat mEyeAdaptHistogramReduce;
 		EyeAdaptationMat mEyeAdaptation;
+		TonemappingMat mTonemapping;
 	};
 
 	/** @} */

Source/RenderBeast/Include/BsRenderBeast.h

@@ -191,6 +191,17 @@ namespace BansheeEngine
 		 */
 		void render(RenderTargetData& rtData, UINT32 camIdx, float delta);
 
+		/**
+		 * Renders all overlay callbacks attached to the provided camera.
+		 *
+		 * @param[in]	rtData	Render target data containing the camera to render.
+		 * @param[in]	camIdx	Index of the camera to render.
+		 * @param[in]	delta	Time elapsed since the last frame.
+		 * 					
+		 * @note	Core thread only.
+		 */
+		void renderOverlay(RenderTargetData& rtData, UINT32 camIdx, float delta);
+
 		/**	Creates data used by the renderer on the core thread. */
 		void initializeCore();
 

Source/RenderBeast/Include/BsRenderTargets.h

@@ -50,9 +50,6 @@ namespace BansheeEngine
 		/**	Binds the scene color render target for rendering. */
 		void bindSceneColor(bool readOnlyDepthStencil);
 
-		/**	Resolves the GBuffer scene color into the output scene color buffer. */
-		void resolve();
-
 		/** Returns the scene color render target. */
 		SPtr<RenderTextureCore> getSceneColorRT() const { return mSceneColorRT; }
 
@@ -90,6 +87,7 @@ namespace BansheeEngine
 		SPtr<MultiRenderTextureCore> mGBufferRT;
 		SPtr<RenderTextureCore> mSceneColorRT;
 
+		PixelFormat mSceneColorFormat;
 		PixelFormat mDiffuseFormat;
 		PixelFormat mNormalFormat;
 		UINT32 mNumSamples;

Source/RenderBeast/Source/BsPostProcessing.cpp

@@ -102,6 +102,8 @@ namespace BansheeEngine
 
 		// TODO - Clear downsampled scene texture as render target before dispatch?
 		RenderAPICore& rapi = RenderAPICore::instance();
+
+		gRendererUtility().setComputePass(mMaterial);
 		rapi.dispatchCompute(threadGroupCount.x, threadGroupCount.y);
 
 		mOutput = ppInfo.histogramTex->renderTexture;
@@ -255,9 +257,42 @@ namespace BansheeEngine
 		gRendererUtility().drawScreenQuad();
 	}
 
-	void PostProcessing::postProcess(const SPtr<RenderTextureCore>& target, PostProcessInfo& ppInfo, float frameDelta)
+	TonemappingMat::TonemappingMat()
+	{
+		mInputTex = mMaterial->getParamTexture("gInputTex");
+		mEyeAdaptationTex = mMaterial->getParamTexture("gEyeAdaptationTex");
+	}
+
+	void TonemappingMat::_initDefines(ShaderDefines& defines)
+	{
+		// Do nothing
+	}
+
+	void TonemappingMat::execute(const SPtr<RenderTextureCore>& sceneColor, const SPtr<ViewportCore>& outputViewport, 
+		PostProcessInfo& ppInfo)
+	{
+		// Set parameters
+		SPtr<TextureCore> colorTexture = sceneColor->getBindableColorTexture();
+		mInputTex.set(colorTexture);
+
+		SPtr<TextureCore> eyeAdaptationTexture = ppInfo.eyeAdaptationTex[ppInfo.lastEyeAdaptationTex]->texture;
+		mEyeAdaptationTex.set(eyeAdaptationTexture);
+
+		// Render
+		RenderAPICore& rapi = RenderAPICore::instance();
+		SPtr<RenderTargetCore> target = outputViewport->getTarget();
+
+		rapi.setRenderTarget(target);
+		rapi.setViewport(outputViewport->getNormArea());
+
+		gRendererUtility().setPass(mMaterial, 0);
+		gRendererUtility().drawScreenQuad();
+	}
+
+	void PostProcessing::postProcess(const SPtr<RenderTextureCore>& sceneColor, const SPtr<ViewportCore>& outputViewport, 
+		PostProcessInfo& ppInfo, float frameDelta)
 	{
-		mDownsample.execute(target, ppInfo);
+		mDownsample.execute(sceneColor, ppInfo);
 		mEyeAdaptHistogram.execute(ppInfo);
 		mDownsample.release(ppInfo);
 
@@ -267,6 +302,9 @@ namespace BansheeEngine
 		mEyeAdaptation.execute(ppInfo, frameDelta);
 		mEyeAdaptHistogramReduce.release(ppInfo);
 
-		// TODO - Generate LUT, run tonemapping, output everything to scene
+		// TODO - Generate LUT with white balancing, color grading, filmic tonemapping
+		// TODO - Apply LUT during tonemapping
+
+		mTonemapping.execute(sceneColor, outputViewport, ppInfo);
 	}
 }

Source/RenderBeast/Source/BsRenderBeast.cpp

@@ -476,7 +476,13 @@ namespace BansheeEngine
 
 			UINT32 numCameras = (UINT32)cameras.size();
 			for (UINT32 i = 0; i < numCameras; i++)
-				render(renderTargetData, i, delta);
+			{
+				bool isOverlayCamera = ((UINT32)cameras[i]->getFlags() & (UINT32)CameraFlags::Overlay) != 0;
+				if (!isOverlayCamera)
+					render(renderTargetData, i, delta);
+				else
+					renderOverlay(renderTargetData, i, delta);
+			}
 
 			RenderAPICore::instance().endFrame();
 			RenderAPICore::instance().swapBuffers(target);
@@ -495,25 +501,20 @@ namespace BansheeEngine
 		SPtr<ViewportCore> viewport = camera->getViewport();
 		CameraShaderData cameraShaderData = getCameraShaderData(*camera);
 
+		assert(((UINT32)camera->getFlags() & (UINT32)CameraFlags::Overlay) == 0);
+
 		mStaticHandler->updatePerCameraBuffers(cameraShaderData);
 
 		// Render scene objects to g-buffer
-		bool hasGBuffer = ((UINT32)camera->getFlags() & (UINT32)CameraFlags::Overlay) == 0;
+		bool createGBuffer = camData.target == nullptr ||
+			camData.target->getHDR() != mCoreOptions->hdr ||
+			camData.target->getNumSamples() != mCoreOptions->msaa;
 
-		if (hasGBuffer)
-		{
-			bool createGBuffer = camData.target == nullptr ||
-				camData.target->getHDR() != mCoreOptions->hdr ||
-				camData.target->getNumSamples() != mCoreOptions->msaa;
+		if (createGBuffer)
+			camData.target = RenderTargets::create(viewport, mCoreOptions->hdr, mCoreOptions->msaa);
 
-			if (createGBuffer)
-				camData.target = RenderTargets::create(viewport, mCoreOptions->hdr, mCoreOptions->msaa);
-
-			camData.target->allocate();
-			camData.target->bindGBuffer();
-		}
-		else
-			camData.target = nullptr;
+		camData.target->allocate();
+		camData.target->bindGBuffer();
 
 		// Trigger pre-scene callbacks
 		auto iterCameraCallbacks = mRenderCallbacks.find(camera);
@@ -533,150 +534,119 @@ namespace BansheeEngine
 			}
 		}
 		
-		if (hasGBuffer)
+		// Render base pass
+		const Vector<RenderQueueElement>& opaqueElements = camData.opaqueQueue->getSortedElements();
+		for (auto iter = opaqueElements.begin(); iter != opaqueElements.end(); ++iter)
 		{
-			// Render base pass
-			const Vector<RenderQueueElement>& opaqueElements = camData.opaqueQueue->getSortedElements();
-			for (auto iter = opaqueElements.begin(); iter != opaqueElements.end(); ++iter)
-			{
-				BeastRenderableElement* renderElem = static_cast<BeastRenderableElement*>(iter->renderElem);
-				SPtr<MaterialCore> material = renderElem->material;
-
-				UINT32 rendererId = renderElem->renderableId;
-				Matrix4 worldViewProjMatrix = cameraShaderData.viewProj * mRenderableShaderData[rendererId].worldTransform;
-
-				mStaticHandler->updatePerObjectBuffers(*renderElem, mRenderableShaderData[rendererId], worldViewProjMatrix);
-				mStaticHandler->bindGlobalBuffers(*renderElem); // Note: If I can keep global buffer slot indexes the same between shaders I could only bind these once
-				mStaticHandler->bindPerObjectBuffers(*renderElem);
-
-				if (iter->applyPass)
-				{
-					SPtr<PassCore> pass = material->getPass(iter->passIdx);
-					setPass(pass);
-				}
+			BeastRenderableElement* renderElem = static_cast<BeastRenderableElement*>(iter->renderElem);
+			SPtr<MaterialCore> material = renderElem->material;
 
-				SPtr<PassParametersCore> passParams = material->getPassParameters(iter->passIdx);
+			UINT32 rendererId = renderElem->renderableId;
+			Matrix4 worldViewProjMatrix = cameraShaderData.viewProj * mRenderableShaderData[rendererId].worldTransform;
 
-				if (renderElem->samplerOverrides != nullptr)
-					setPassParams(passParams, &renderElem->samplerOverrides->passes[iter->passIdx]);
-				else
-					setPassParams(passParams, nullptr);
+			mStaticHandler->updatePerObjectBuffers(*renderElem, mRenderableShaderData[rendererId], worldViewProjMatrix);
+			mStaticHandler->bindGlobalBuffers(*renderElem); // Note: If I can keep global buffer slot indexes the same between shaders I could only bind these once
+			mStaticHandler->bindPerObjectBuffers(*renderElem);
 
-				gRendererUtility().draw(iter->renderElem->mesh, iter->renderElem->subMesh);
+			if (iter->applyPass)
+			{
+				SPtr<PassCore> pass = material->getPass(iter->passIdx);
+				setPass(pass);
 			}
 
-			camData.target->bindSceneColor(true);
-
-			// Render light pass
-			SPtr<GpuParamBlockBufferCore> perCameraBuffer = mStaticHandler->getPerCameraParams().getBuffer();
+			SPtr<PassParametersCore> passParams = material->getPassParameters(iter->passIdx);
 
-			SPtr<MaterialCore> dirMaterial = mDirLightMat->getMaterial();
-			SPtr<PassCore> dirPass = dirMaterial->getPass(0);
+			if (renderElem->samplerOverrides != nullptr)
+				setPassParams(passParams, &renderElem->samplerOverrides->passes[iter->passIdx]);
+			else
+				setPassParams(passParams, nullptr);
 
-			setPass(dirPass);
-			mDirLightMat->setStaticParameters(camData.target, perCameraBuffer);
+			gRendererUtility().draw(iter->renderElem->mesh, iter->renderElem->subMesh);
+		}
 
-			for (auto& light : mDirectionalLights)
-			{
-				if (!light.internal->getIsActive())
-					continue;
+		camData.target->bindSceneColor(true);
 
-				mDirLightMat->setParameters(light.internal);
+		// Render light pass
+		SPtr<GpuParamBlockBufferCore> perCameraBuffer = mStaticHandler->getPerCameraParams().getBuffer();
 
-				// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
-				//  - I can't think of a good way to do this automatically. Probably best to do it in setParameters()
-				setPassParams(dirMaterial->getPassParameters(0), nullptr);
-				gRendererUtility().drawScreenQuad();
-			}
+		SPtr<MaterialCore> dirMaterial = mDirLightMat->getMaterial();
+		SPtr<PassCore> dirPass = dirMaterial->getPass(0);
 
-			// Draw point lights which our camera is within
-			SPtr<MaterialCore> pointInsideMaterial = mPointLightInMat->getMaterial();
-			SPtr<PassCore> pointInsidePass = pointInsideMaterial->getPass(0);
+		setPass(dirPass);
+		mDirLightMat->setStaticParameters(camData.target, perCameraBuffer);
 
-			// TODO - Possibly use instanced drawing here as only two meshes are drawn with various properties
-			setPass(pointInsidePass);
-			mPointLightInMat->setStaticParameters(camData.target, perCameraBuffer);
+		for (auto& light : mDirectionalLights)
+		{
+			if (!light.internal->getIsActive())
+				continue;
 
-			// TODO - Cull lights based on visibility, right now I just iterate over all of them. 
-			for (auto& light : mPointLights)
-			{
-				if (!light.internal->getIsActive())
-					continue;
+			mDirLightMat->setParameters(light.internal);
 
-				float distToLight = (light.internal->getBounds().getCenter() - camera->getPosition()).squaredLength();
-				float boundRadius = light.internal->getBounds().getRadius() * 1.05f + camera->getNearClipDistance() * 2.0f;
+			// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
+			//  - I can't think of a good way to do this automatically. Probably best to do it in setParameters()
+			setPassParams(dirMaterial->getPassParameters(0), nullptr);
+			gRendererUtility().drawScreenQuad();
+		}
 
-				bool cameraInLightGeometry = distToLight < boundRadius * boundRadius;
-				if (!cameraInLightGeometry)
-					continue;
+		// Draw point lights which our camera is within
+		SPtr<MaterialCore> pointInsideMaterial = mPointLightInMat->getMaterial();
+		SPtr<PassCore> pointInsidePass = pointInsideMaterial->getPass(0);
 
-				mPointLightInMat->setParameters(light.internal);
+		// TODO - Possibly use instanced drawing here as only two meshes are drawn with various properties
+		setPass(pointInsidePass);
+		mPointLightInMat->setStaticParameters(camData.target, perCameraBuffer);
 
-				// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
-				//  - I can't think of a good way to do this automatically. Probably best to do it in setParameters()
-				setPassParams(pointInsideMaterial->getPassParameters(0), nullptr);
-				SPtr<MeshCore> mesh = light.internal->getMesh();
-				gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
-			}
+		// TODO - Cull lights based on visibility, right now I just iterate over all of them. 
+		for (auto& light : mPointLights)
+		{
+			if (!light.internal->getIsActive())
+				continue;
 
-			// Draw other point lights
-			SPtr<MaterialCore> pointOutsideMaterial = mPointLightOutMat->getMaterial();
-			SPtr<PassCore> pointOutsidePass = pointOutsideMaterial->getPass(0);
+			float distToLight = (light.internal->getBounds().getCenter() - camera->getPosition()).squaredLength();
+			float boundRadius = light.internal->getBounds().getRadius() * 1.05f + camera->getNearClipDistance() * 2.0f;
 
-			setPass(pointOutsidePass);
-			mPointLightOutMat->setStaticParameters(camData.target, perCameraBuffer);
+			bool cameraInLightGeometry = distToLight < boundRadius * boundRadius;
+			if (!cameraInLightGeometry)
+				continue;
 
-			for (auto& light : mPointLights)
-			{
-				if (!light.internal->getIsActive())
-					continue;
+			mPointLightInMat->setParameters(light.internal);
 
-				float distToLight = (light.internal->getBounds().getCenter() - camera->getPosition()).squaredLength();
-				float boundRadius = light.internal->getBounds().getRadius() * 1.05f + camera->getNearClipDistance() * 2.0f;
+			// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
+			//  - I can't think of a good way to do this automatically. Probably best to do it in setParameters()
+			setPassParams(pointInsideMaterial->getPassParameters(0), nullptr);
+			SPtr<MeshCore> mesh = light.internal->getMesh();
+			gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
+		}
 
-				bool cameraInLightGeometry = distToLight < boundRadius * boundRadius;
-				if (cameraInLightGeometry)
-					continue;
+		// Draw other point lights
+		SPtr<MaterialCore> pointOutsideMaterial = mPointLightOutMat->getMaterial();
+		SPtr<PassCore> pointOutsidePass = pointOutsideMaterial->getPass(0);
 
-				mPointLightOutMat->setParameters(light.internal);
+		setPass(pointOutsidePass);
+		mPointLightOutMat->setStaticParameters(camData.target, perCameraBuffer);
 
-				// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
-				setPassParams(pointOutsideMaterial->getPassParameters(0), nullptr);
-				SPtr<MeshCore> mesh = light.internal->getMesh();
-				gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
-			}
-
-			camData.target->bindSceneColor(false);
-		}
-		else
+		for (auto& light : mPointLights)
 		{
-			// Prepare final render target
-			SPtr<RenderTargetCore> target = rtData.target;
-
-			RenderAPICore::instance().setRenderTarget(target);
-			RenderAPICore::instance().setViewport(viewport->getNormArea());
+			if (!light.internal->getIsActive())
+				continue;
 
-			// If first camera in render target, prepare the render target
-			if (camIdx == 0)
-			{
-				UINT32 clearBuffers = 0;
-				if (viewport->getRequiresColorClear())
-					clearBuffers |= FBT_COLOR;
+			float distToLight = (light.internal->getBounds().getCenter() - camera->getPosition()).squaredLength();
+			float boundRadius = light.internal->getBounds().getRadius() * 1.05f + camera->getNearClipDistance() * 2.0f;
 
-				if (viewport->getRequiresDepthClear())
-					clearBuffers |= FBT_DEPTH;
+			bool cameraInLightGeometry = distToLight < boundRadius * boundRadius;
+			if (cameraInLightGeometry)
+				continue;
 
-				if (viewport->getRequiresStencilClear())
-					clearBuffers |= FBT_STENCIL;
+			mPointLightOutMat->setParameters(light.internal);
 
-				if (clearBuffers != 0)
-				{
-					RenderAPICore::instance().clearViewport(clearBuffers, viewport->getClearColor(),
-						viewport->getClearDepthValue(), viewport->getClearStencilValue());
-				}
-			}
+			// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
+			setPassParams(pointOutsideMaterial->getPassParameters(0), nullptr);
+			SPtr<MeshCore> mesh = light.internal->getMesh();
+			gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
 		}
 
+		camData.target->bindSceneColor(false);
+		
 		// Render transparent objects (TODO - No lighting yet)
 		const Vector<RenderQueueElement>& transparentElements = camData.transparentQueue->getSortedElements();
 		for (auto iter = transparentElements.begin(); iter != transparentElements.end(); ++iter)
@@ -724,20 +694,70 @@ namespace BansheeEngine
 			}
 		}
 
-		if (hasGBuffer)
+		// TODO - If GBuffer has multiple samples, I should resolve them before post-processing
+		PostProcessing::instance().postProcess(camData.target->getSceneColorRT(), 
+			viewport, camData.postProcessInfo, delta);
+
+		// Render overlay post-scene callbacks
+		if (iterCameraCallbacks != mRenderCallbacks.end())
 		{
-			//PostProcessing::instance().postProcess(camData.target->getSceneColorRT(), camData.postProcessInfo, delta);
+			for (auto& callbackPair : iterCameraCallbacks->second)
+			{
+				const RenderCallbackData& callbackData = callbackPair.second;
+
+				if (!callbackData.overlay)
+					continue;
 
-			// TODO - Instead of doing a separate resolve here I could potentially perform a resolve directly in some
-			// post-processing pass (e.g. tone mapping). Right now it is just an unnecessary blit.
-			camData.target->resolve();
+				callbackData.callback();
+			}
 		}
-		else
+
+		camData.target->release();
+
+		gProfilerCPU().endSample("Render");
+	}
+
+	void RenderBeast::renderOverlay(RenderTargetData& rtData, UINT32 camIdx, float delta)
+	{
+		gProfilerCPU().beginSample("RenderOverlay");
+
+		const CameraCore* camera = rtData.cameras[camIdx];
+		CameraData& camData = mCameraData[camera];
+
+		assert(((UINT32)camera->getFlags() & (UINT32)CameraFlags::Overlay) != 0);
+
+		SPtr<ViewportCore> viewport = camera->getViewport();
+		CameraShaderData cameraShaderData = getCameraShaderData(*camera);
+
+		mStaticHandler->updatePerCameraBuffers(cameraShaderData);
+
+		SPtr<RenderTargetCore> target = rtData.target;
+
+		RenderAPICore::instance().setRenderTarget(target);
+		RenderAPICore::instance().setViewport(viewport->getNormArea());
+
+		// If first camera in render target, prepare the render target
+		if (camIdx == 0)
 		{
-			// TODO - Post process without gbuffer
+			UINT32 clearBuffers = 0;
+			if (viewport->getRequiresColorClear())
+				clearBuffers |= FBT_COLOR;
+
+			if (viewport->getRequiresDepthClear())
+				clearBuffers |= FBT_DEPTH;
+
+			if (viewport->getRequiresStencilClear())
+				clearBuffers |= FBT_STENCIL;
+
+			if (clearBuffers != 0)
+			{
+				RenderAPICore::instance().clearViewport(clearBuffers, viewport->getClearColor(),
+					viewport->getClearDepthValue(), viewport->getClearStencilValue());
+			}
 		}
 
 		// Render overlay post-scene callbacks
+		auto iterCameraCallbacks = mRenderCallbacks.find(camera);
 		if (iterCameraCallbacks != mRenderCallbacks.end())
 		{
 			for (auto& callbackPair : iterCameraCallbacks->second)
@@ -751,14 +771,15 @@ namespace BansheeEngine
 			}
 		}
 
-		if (hasGBuffer)
-			camData.target->release();
-
-		gProfilerCPU().endSample("Render");
+		gProfilerCPU().endSample("RenderOverlay");
 	}
 	
 	void RenderBeast::determineVisible(const CameraCore& camera)
 	{
+		bool isOverlayCamera = ((UINT32)camera.getFlags() & (UINT32)CameraFlags::Overlay) != 0;
+		if (isOverlayCamera)
+			return;
+
 		CameraData& cameraData = mCameraData[&camera];
 
 		UINT64 cameraLayers = camera.getLayers();

Source/RenderBeast/Source/BsRenderTargets.cpp

@@ -12,12 +12,10 @@ namespace BansheeEngine
 	RenderTargets::RenderTargets(const SPtr<ViewportCore>& viewport, bool hdr, UINT32 numSamples)
 		:mViewport(viewport), mNumSamples(numSamples), mHDR(hdr)
 	{
-		if (hdr)
-			mDiffuseFormat = PF_FLOAT_R11G11B10;
-		else
-			mDiffuseFormat = PF_B8G8R8X8;
-
-		mNormalFormat = PF_UNORM_R10G10B10A2;
+		// Note: Consider customizable HDR format via options? e.g. smaller PF_FLOAT_R11G11B10 or larger 32-bit format
+		mSceneColorFormat = hdr ? PF_FLOAT16_RGBA : PF_B8G8R8X8;
+		mDiffuseFormat = PF_B8G8R8X8; // Note: Also consider customizable format (e.g. 16-bit float?)
+		mNormalFormat = PF_UNORM_R10G10B10A2; // Note: Also consider customizable format (e.g. 16-bit float?)
 	}
 
 	SPtr<RenderTargets> RenderTargets::create(const SPtr<ViewportCore>& viewport, bool hdr, UINT32 numSamples)
@@ -32,6 +30,8 @@ namespace BansheeEngine
 		UINT32 width = getWidth();
 		UINT32 height = getHeight();
 
+		SPtr<PooledRenderTexture> newColorRT = texPool.get(POOLED_RENDER_TEXTURE_DESC::create2D(mSceneColorFormat, width, height, TU_RENDERTARGET,
+			mNumSamples, false));
 		SPtr<PooledRenderTexture> newAlbedoRT = texPool.get(POOLED_RENDER_TEXTURE_DESC::create2D(mDiffuseFormat, width, 
 			height, TU_RENDERTARGET, mNumSamples, false));
 		SPtr<PooledRenderTexture> newNormalRT = texPool.get(POOLED_RENDER_TEXTURE_DESC::create2D(mNormalFormat, width, 
@@ -39,22 +39,6 @@ namespace BansheeEngine
 		SPtr<PooledRenderTexture> newDepthRT = texPool.get(POOLED_RENDER_TEXTURE_DESC::create2D(PF_D24S8, width, height, 
 			TU_DEPTHSTENCIL, mNumSamples, false));
 
-		SPtr<PooledRenderTexture> newColorRT = nullptr;
-
-		// See if I can use the final output color target for gbuffer rendering, this saves a little memory
-		SPtr<RenderTargetCore> resolvedRT = mViewport->getTarget();
-		const RenderTargetProperties& resolvedRTProps = resolvedRT->getProperties();
-
-		bool useResolvedColor = !resolvedRTProps.isWindow() &&
-			mViewport->getWidth() == getWidth() &&
-			mViewport->getHeight() == getHeight() &&
-			((resolvedRTProps.getMultisampleCount() <= 1) == (mNumSamples <= 1) ||
-			resolvedRTProps.getMultisampleCount() == mNumSamples);
-
-		if (!useResolvedColor)
-			newColorRT = texPool.get(POOLED_RENDER_TEXTURE_DESC::create2D(PF_B8G8R8X8, width, height, TU_RENDERTARGET, 
-				mNumSamples, false));
-
 		bool rebuildTargets = newColorRT != mSceneColorTex || newAlbedoRT != mAlbedoTex || newNormalRT != mNormalTex || newDepthRT != mDepthTex;
 
 		mSceneColorTex = newColorRT;
@@ -67,17 +51,7 @@ namespace BansheeEngine
 			MULTI_RENDER_TEXTURE_CORE_DESC gbufferDesc;
 			gbufferDesc.colorSurfaces.resize(3);
 
-			SPtr<TextureCore> sceneColorTex = nullptr;
-
-			if (newColorRT != nullptr)
-				sceneColorTex = newColorRT->texture;
-			else // Re-using output scene color texture
-			{
-				SPtr<RenderTextureCore> resolvedRTex = std::static_pointer_cast<RenderTextureCore>(resolvedRT);
-				sceneColorTex = resolvedRTex->getBindableColorTexture();
-			}
-
-			gbufferDesc.colorSurfaces[0].texture = sceneColorTex;
+			gbufferDesc.colorSurfaces[0].texture = mSceneColorTex->texture;
 			gbufferDesc.colorSurfaces[0].face = 0;
 			gbufferDesc.colorSurfaces[0].mipLevel = 0;
 
@@ -96,7 +70,7 @@ namespace BansheeEngine
 			mGBufferRT = TextureCoreManager::instance().createMultiRenderTexture(gbufferDesc);
 
 			RENDER_TEXTURE_CORE_DESC sceneColorDesc;
-			sceneColorDesc.colorSurface.texture = sceneColorTex;
+			sceneColorDesc.colorSurface.texture = mSceneColorTex->texture;
 			sceneColorDesc.colorSurface.face = 0;
 			sceneColorDesc.colorSurface.mipLevel = 0;
 
@@ -115,9 +89,7 @@ namespace BansheeEngine
 
 		RenderTexturePool& texPool = RenderTexturePool::instance();
 
-		if (mSceneColorTex != nullptr)
-			texPool.release(mSceneColorTex);
-
+		texPool.release(mSceneColorTex);
 		texPool.release(mAlbedoTex);
 		texPool.release(mNormalTex);
 		texPool.release(mDepthTex);
@@ -161,42 +133,6 @@ namespace BansheeEngine
 		rapi.setViewport(area);
 	}
 
-	void RenderTargets::resolve()
-	{
-		// Prepare final render target
-		SPtr<RenderTargetCore> target = mViewport->getTarget();
-
-		RenderAPICore::instance().setRenderTarget(target);
-		RenderAPICore::instance().setViewport(mViewport->getNormArea());
-
-		// If using a separate scene color texture clear the final render target
-		if (mSceneColorTex == nullptr)
-		{
-			// Do nothing as final render target is already our scene color target
-		}
-		else
-		{
-			UINT32 clearBuffers = 0;
-			if (mViewport->getRequiresColorClear())
-				clearBuffers |= FBT_COLOR;
-
-			if (mViewport->getRequiresDepthClear())
-				clearBuffers |= FBT_DEPTH;
-
-			if (mViewport->getRequiresStencilClear())
-				clearBuffers |= FBT_STENCIL;
-
-			if (clearBuffers != 0)
-			{
-				RenderAPICore::instance().clearViewport(clearBuffers, mViewport->getClearColor(),
-					mViewport->getClearDepthValue(), mViewport->getClearStencilValue());
-			}
-
-			// TODO - Merge this blit into some post-processing shader, no reason for it to be on its own
-			gRendererUtility().blit(mSceneColorTex->texture);
-		}
-	}
-
 	SPtr<TextureCore> RenderTargets::getTextureA() const
 	{
 		return mAlbedoTex->texture;

Source/SBansheeEngine/Source/BsManagedComponent.cpp

@@ -12,7 +12,6 @@
 #include "BsScriptAssemblyManager.h"
 #include "BsMonoAssembly.h"
 #include "BsPlayInEditorManager.h"
-#include "BsDebug.h"
 
 namespace BansheeEngine
 {