WIP: Introduce the lighting pass betwee the G-Buffer and post-process passes

Carmelo · Carmelo · commit 54d7fce5bae5 · 2023-06-25T16:50:38.000-07:00
diff --git a/engine/gfx/renderer/RenderPass.cpp b/engine/gfx/renderer/RenderPass.cpp
@@ -88,7 +88,7 @@ namespace rev::gfx
 
 	void RenderPass::setClearColor(const std::vector<Vec4f>& colors)
 	{
-		m_clearColor = true;
+		m_clearColor = !colors.empty();
 		m_clearColors.reserve(colors.size());
 		m_clearColors.clear();
 
diff --git a/engine/gfx/renderer/RenderPass.h b/engine/gfx/renderer/RenderPass.h
@@ -42,12 +42,12 @@ namespace rev::gfx
 
 		void begin(vk::CommandBuffer cmd, const math::Vec2u& targetSize);
 
+		void resetClearDepth() { m_clearZ = false; }
 		void setClearDepth(float depth);
 
+		void resetClearColor() { m_clearColor = false; }
 		void setClearColor(const std::vector<math::Vec4f>& colors);
-
 		void setClearColor(const math::Vec4f& c);
-
 		void setClearColor(const math::Vec3f& c);
 
 		void setColorTargets(const std::vector<const gfx::ImageBuffer*>& colorTargets);
diff --git a/engine/gfx/renderer/deferred/DeferredRenderer.cpp b/engine/gfx/renderer/deferred/DeferredRenderer.cpp
@@ -98,7 +98,7 @@ namespace rev::gfx
 		
 		// Update render passes
 		m_gBufferPass->setDepthTarget(*m_zBuffer);
-		m_gBufferPass->setColorTargets({ m_hdrLightBuffer.get() });
+		m_gBufferPass->setColorTargets({ m_emissiveBuffer.get(), m_baseColorMetalnessBuffer.get(), m_normalPBRBuffer.get() });
 
 		gfx::DescriptorSetUpdate renderBufferUpdates(*m_postProDescriptors, 0);
 		renderBufferUpdates.addImage("HDR Light", m_hdrLightBuffer);
@@ -201,6 +201,45 @@ namespace rev::gfx
 		m_gBufferPass->end(cmd);
 	}
 
+	//---------------------------------------------------------------------------------------------------------------------
+	void DeferredRenderer::renderLightingPass()
+	{
+		m_lightingConstants.windowSize = math::Vec2f((float)m_windowSize.x(), (float)m_windowSize.y());
+		m_lightingConstants.lightDir = m_frameConstants.lightDir;
+		m_lightingConstants.lightColor = m_frameConstants.lightColor;
+
+		auto cmd = m_ctxt->getNewRenderCmdBuffer();
+		cmd.begin(vk::CommandBufferBeginInfo(vk::CommandBufferUsageFlagBits::eOneTimeSubmit));
+
+		m_ctxt->allocator().transitionImageLayout(cmd, m_emissiveBuffer->image(), vk::ImageLayout::eGeneral, vk::ImageLayout::eShaderReadOnlyOptimal, false);
+		m_ctxt->allocator().transitionImageLayout(cmd, m_baseColorMetalnessBuffer->image(), vk::ImageLayout::eGeneral, vk::ImageLayout::eShaderReadOnlyOptimal, false);
+		m_ctxt->allocator().transitionImageLayout(cmd, m_normalPBRBuffer->image(), vk::ImageLayout::eGeneral, vk::ImageLayout::eShaderReadOnlyOptimal, false);
+		m_lightingPass->begin(
+			cmd,
+			m_windowSize,
+			*m_hdrLightBuffer,
+			nullptr,
+			m_lightingDescriptors->getDescriptor(0));
+
+		m_lightingPass->pushConstants(cmd, m_lightingConstants);
+		m_lightingPass->render(cmd);
+
+		m_lightingPass->end(cmd);
+
+		m_ctxt->allocator().transitionImageLayout(cmd, m_emissiveBuffer->image(), vk::ImageLayout::eShaderReadOnlyOptimal, vk::ImageLayout::eGeneral, false);
+		m_ctxt->allocator().transitionImageLayout(cmd, m_baseColorMetalnessBuffer->image(), vk::ImageLayout::eShaderReadOnlyOptimal, vk::ImageLayout::eGeneral, false);
+		m_ctxt->allocator().transitionImageLayout(cmd, m_normalPBRBuffer->image(), vk::ImageLayout::eShaderReadOnlyOptimal, vk::ImageLayout::eGeneral, false);
+
+		cmd.end();
+
+		vk::PipelineStageFlags waitFlags = {};
+		vk::SubmitInfo submitInfo(
+			0, nullptr, &waitFlags, // wait
+			1, &cmd, // commands
+			0, nullptr); // signal
+		static_cast<VulkanCommandQueue&>(m_ctxt->GfxQueue()).nativeQueue().submit(submitInfo);
+	}
+
 	//---------------------------------------------------------------------------------------------------------------------
 	void DeferredRenderer::renderPostProPass()
 	{
@@ -219,7 +258,7 @@ namespace rev::gfx
 			cmd,
 			m_windowSize,
 			swapchainImage,
-			m_postProConstants.ambientColor,
+			&m_postProConstants.ambientColor,
 			m_postProDescriptors->getDescriptor(0));
 
 		m_postPass->pushConstants(cmd, m_postProConstants);
@@ -426,12 +465,20 @@ namespace rev::gfx
 		auto windowSize = m_ctxt->windowSize();
 		auto& alloc = m_ctxt->allocator();
 
+		m_emissiveBuffer = alloc.createImageBuffer(
+			"HDR light",
+			windowSize,
+			m_HDRFormat,
+			vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eStorage,
+			m_ctxt->graphicsQueueFamily());
+
 		m_hdrLightBuffer = alloc.createImageBuffer(
 			"HDR light",
 			windowSize,
 			m_HDRFormat,
 			vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eStorage,
 			m_ctxt->graphicsQueueFamily());
+
 		m_zBuffer = alloc.createDepthBuffer(
 			"Depth",
 			windowSize,
@@ -462,6 +509,7 @@ namespace rev::gfx
 	void DeferredRenderer::destroyRenderTargets()
 	{
 		m_hdrLightBuffer = nullptr;
+		m_emissiveBuffer = nullptr;
 		m_zBuffer = nullptr;
 		m_normalPBRBuffer = nullptr;
 		m_normalPBRBuffer = nullptr;
diff --git a/engine/gfx/renderer/deferred/DeferredRenderer.h b/engine/gfx/renderer/deferred/DeferredRenderer.h
@@ -81,6 +81,7 @@ namespace rev::gfx
 		void loadIBLLUT();
 
 		void renderGeometryPass(SceneDesc& scene);
+		void renderLightingPass();
 		void renderPostProPass();
 
 		// Init ImGui
@@ -113,6 +114,7 @@ namespace rev::gfx
 		std::unique_ptr<gfx::RasterPipeline> m_postPipeline;
 
 		std::shared_ptr<gfx::ImageBuffer> m_hdrLightBuffer;
+		std::shared_ptr<gfx::ImageBuffer> m_emissiveBuffer;
 		std::shared_ptr<gfx::ImageBuffer> m_baseColorMetalnessBuffer;
 		std::shared_ptr<gfx::ImageBuffer> m_normalPBRBuffer;
 		std::shared_ptr<gfx::ImageBuffer> m_zBuffer;
@@ -138,9 +140,12 @@ namespace rev::gfx
 
 		struct LightingPushConstants
 		{
+			uint32_t renderFlags;
+			math::Vec2f windowSize;
 			math::Vec3f lightDir;
 			math::Vec3f lightColor;
-		};
+			math::Vec3f ambientColor;
+		} m_lightingConstants;
 
 		struct PostProPushConstants
 		{
diff --git a/engine/gfx/renderer/renderPass/fullScreenPass.cpp b/engine/gfx/renderer/renderPass/fullScreenPass.cpp
@@ -78,11 +78,14 @@ namespace rev::gfx
 		const vk::CommandBuffer cmd,
 		const math::Vec2u& targetSize,
 		const ImageBuffer& colorTarget,
-		const math::Vec3f& clearColor,
+		const math::Vec3f* clearColor,
 		vk::DescriptorSet descriptor)
 	{
 		m_renderPass->setColorTarget(colorTarget);
-		m_renderPass->setClearColor(clearColor);
+		if (clearColor)
+			m_renderPass->setClearColor(*clearColor);
+		else
+			m_renderPass->resetClearColor();
 
 		RenderContextVk().allocator().transitionImageLayout(cmd,
 			colorTarget.image(),
diff --git a/engine/gfx/renderer/renderPass/fullScreenPass.h b/engine/gfx/renderer/renderPass/fullScreenPass.h
@@ -44,7 +44,7 @@ namespace rev::gfx {
 			const vk::CommandBuffer cmd,
 			const math::Vec2u& targetSize,
 			const ImageBuffer& colorTargets,
-			const math::Vec3f& clearColor,
+			const math::Vec3f* clearColor,
 			vk::DescriptorSet descriptor);
 
 		template<class PushConstants>
diff --git a/samples/ShaderToy/ShaderToy.cpp b/samples/ShaderToy/ShaderToy.cpp
@@ -177,7 +177,7 @@ namespace rev
 			cmd,
 			RenderContext().windowSize(),
 			RenderContextVk().swapchainAquireNextImage(m_imageAvailableSemaphore, cmd),
-			Vec3f(0),
+			nullptr,
 			m_descSets->getDescriptor(0));
 
 		m_fullScreenFilter->pushConstants(cmd, m_frameConstants);
diff --git a/samples/pluto/shaders/lighting.frag b/samples/pluto/shaders/lighting.frag
@@ -26,7 +26,6 @@
 #include "pbr.glsl"
 
 layout(location = 0) in vec2 vPxlTexCoord;
-
 layout(location = 0) out vec4 outColor;
 
 layout(set = 0, binding = 0, rgba32f) uniform image2D HDRLight;
@@ -37,10 +36,10 @@ layout(set = 0, binding = 3, r32f) uniform image2D depth;
 layout(push_constant,scalar) uniform Constants
 {
 	uint renderFlags;
-	vec3 ambientColor;
 	vec2 windowSize;
-	float exposure;
-	float bloom;
+	vec3 lightDir;
+	vec3 lightColor;
+	vec3 ambientColor;
 } pushC;
 
 void main()
@@ -49,44 +48,13 @@ void main()
 		pushC.windowSize.x * vPxlTexCoord.x,
 		pushC.windowSize.y * vPxlTexCoord.y);
 
-	// Gather slight bloom
-	vec4 hdrColor = vec4(0);
-	int bloomWin = 0;
-	ivec2 minPos = max(pixelPos-bloomWin, ivec2(0));
-	ivec2 maxPos = min(pixelPos+bloomWin, ivec2(pushC.windowSize-1));
+	// Read from the G-Buffer
+	vec4 litColor = imageLoad(HDRLight, pixelPos);
 
-	//if(bloomWin == 0)
+	if(litColor.w < 0) // composite with the sky
 	{
-		vec4 bloomColor = imageLoad(HDRLight, pixelPos);
-		if(bloomColor.w < 0)
-		{
-			bloomColor = vec4(pushC.ambientColor,1);
-		}
-		hdrColor += bloomColor;
+		litColor = vec4(pushC.ambientColor, 1);
 	}
-	if(bloomWin > 0)
-	{
-		for(int j = minPos.y; j <= maxPos.y; ++j)
-		{
-			for(int i = minPos.x; i <= maxPos.x; ++i)
-			{
-				if(ivec2(i,j) == pixelPos)
-					continue;
-				float distance = 100 * (float(abs(i-pixelPos.x) * abs(j-pixelPos.y))) / pushC.windowSize.y;
-				float weight = exp(-distance);
 
-				vec4 bloomColor = imageLoad(HDRLight, ivec2(i, j));
-				if(bloomColor.w < 0)
-				{
-					bloomColor = vec4(pushC.ambientColor,1);
-				}
-				vec4 delta = weight * pow(bloomColor, vec4(2));
-				//delta = pow(delta, vec4(2)); 
-				hdrColor += 0.001 * delta;
-			}
-		}
-	}
-	hdrColor *= pushC.exposure;
-	vec4 toneMapped = hdrColor / (1 + hdrColor);
-	outColor = toneMapped;
+	outColor = litColor;
 }

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ namespace rev::gfx`
`88`	`88`
`89`	`89`	`void RenderPass::setClearColor(const std::vector<Vec4f>& colors)`
`90`	`90`	`{`
`91`		`- m_clearColor = true;`
	`91`	`+ m_clearColor = !colors.empty();`
`92`	`92`	`m_clearColors.reserve(colors.size());`
`93`	`93`	`m_clearColors.clear();`
`94`	`94`