WIP: using Unreal Engine's way to do RenderGraph

Author: sheazywi

Core/Source/Lux/Renderer/RenderGraph.cpp

@@ -2,6 +2,7 @@
 #include "RenderGraph.h"
 
 #include <algorithm>
+#include <format>
 
 namespace Lux {
 
@@ -17,12 +18,24 @@ namespace Lux {
 		return static_cast<ResourceHandle>(m_Textures.size() - 1);
 	}
 
-	uint32_t RenderGraph::AddPass(const PassDesc& desc)
+	uint32_t RenderGraph::AddPass(PassDesc desc)
 	{
-		m_Passes.push_back(desc);
+		NormalizeResourceList(desc.Reads);
+		NormalizeResourceList(desc.Writes);
+
+		if (desc.Name.empty())
+			desc.Name = std::format("Pass {}", m_Passes.size());
+
+		m_Passes.push_back(std::move(desc));
 		return static_cast<uint32_t>(m_Passes.size() - 1);
 	}
 
+	uint32_t RenderGraph::AddPass(PassDesc desc, ExecuteCallback execute)
+	{
+		desc.Execute = std::move(execute);
+		return AddPass(std::move(desc));
+	}
+
 	bool RenderGraph::AreAliasCompatible(const TextureDesc& lhs, const TextureDesc& rhs)
 	{
 		return lhs.Transient && rhs.Transient
@@ -36,7 +49,14 @@ namespace Lux {
 			&& lhs.Layers == rhs.Layers;
 	}
 
-	std::vector<RenderGraph::ResourceLifetime> RenderGraph::BuildAliasPlan() const
+	void RenderGraph::NormalizeResourceList(std::vector<ResourceHandle>& resources)
+	{
+		resources.erase(std::remove(resources.begin(), resources.end(), InvalidResource), resources.end());
+		std::sort(resources.begin(), resources.end());
+		resources.erase(std::unique(resources.begin(), resources.end()), resources.end());
+	}
+
+	std::vector<RenderGraph::ResourceLifetime> RenderGraph::BuildResourceLifetimes(std::vector<std::string>* diagnostics) const
 	{
 		std::vector<ResourceLifetime> lifetimes(m_Textures.size());
 		for (ResourceHandle resource = 0; resource < m_Textures.size(); resource++)
@@ -48,7 +68,11 @@ namespace Lux {
 			auto touchResource = [&](ResourceHandle resource)
 				{
 					if (resource >= lifetimes.size())
+					{
+						if (diagnostics)
+							diagnostics->push_back(std::format("Pass '{}' references invalid resource {}", pass.Name, resource));
 						return;
+					}
 
 					ResourceLifetime& lifetime = lifetimes[resource];
 					lifetime.FirstPass = std::min(lifetime.FirstPass, passIndex);
@@ -61,6 +85,94 @@ namespace Lux {
 				touchResource(resource);
 		}
 
+		return lifetimes;
+	}
+
+	RenderGraph::CompileResult RenderGraph::Compile() const
+	{
+		CompileResult result;
+		result.Lifetimes = BuildResourceLifetimes(&result.Diagnostics);
+		result.Valid = result.Diagnostics.empty();
+
+		std::vector<bool> neededResources(m_Textures.size(), false);
+		for (ResourceHandle resource = 0; resource < m_Textures.size(); resource++)
+		{
+			const TextureDesc& texture = m_Textures[resource];
+			if (!texture.Transient)
+				neededResources[resource] = true;
+		}
+
+		std::vector<bool> passNeeded(m_Passes.size(), false);
+		for (uint32_t passIndex = static_cast<uint32_t>(m_Passes.size()); passIndex > 0; passIndex--)
+		{
+			const uint32_t index = passIndex - 1;
+			const PassDesc& pass = m_Passes[index];
+
+			const bool pinned = HasFlag(pass.Flags, PassFlags::SideEffect) || HasFlag(pass.Flags, PassFlags::NeverCull);
+			bool writesNeededOutput = false;
+			for (ResourceHandle resource : pass.Writes)
+			{
+				if (resource < neededResources.size() && neededResources[resource])
+				{
+					writesNeededOutput = true;
+					break;
+				}
+			}
+
+			const bool keepPass = pinned || writesNeededOutput;
+			passNeeded[index] = keepPass;
+			if (!keepPass)
+				continue;
+
+			for (ResourceHandle resource : pass.Writes)
+			{
+				if (resource < neededResources.size())
+					neededResources[resource] = false;
+			}
+
+			for (ResourceHandle resource : pass.Reads)
+			{
+				if (resource < neededResources.size())
+					neededResources[resource] = true;
+			}
+		}
+
+		result.ExecutionOrder.reserve(m_Passes.size());
+		for (uint32_t passIndex = 0; passIndex < m_Passes.size(); passIndex++)
+		{
+			if (passNeeded[passIndex])
+				result.ExecutionOrder.push_back(passIndex);
+			else
+				result.CulledPasses.push_back(passIndex);
+		}
+
+		return result;
+	}
+
+	RenderGraph::CompileResult RenderGraph::Execute() const
+	{
+		CompileResult result = Compile();
+		Execute(result);
+		return result;
+	}
+
+	void RenderGraph::Execute(const CompileResult& compileResult) const
+	{
+		for (uint32_t passIndex : compileResult.ExecutionOrder)
+		{
+			if (passIndex >= m_Passes.size())
+				continue;
+
+			const PassDesc& pass = m_Passes[passIndex];
+			if (pass.Execute)
+				pass.Execute();
+		}
+	}
+
+	std::vector<RenderGraph::ResourceLifetime> RenderGraph::BuildAliasPlan() const
+	{
+		std::vector<ResourceLifetime> lifetimes = BuildResourceLifetimes();
+
 		std::vector<ResourceHandle> lifetimeOrder;
 		lifetimeOrder.reserve(lifetimes.size());
 		for (ResourceHandle resource = 0; resource < lifetimes.size(); resource++)

Core/Source/Lux/Renderer/RenderGraph.h

@@ -3,6 +3,7 @@
 #include "Lux/Renderer/Image.h"
 
 #include <cstdint>
+#include <functional>
 #include <string>
 #include <vector>
 
@@ -12,8 +13,19 @@ namespace Lux {
 	{
 	public:
 		using ResourceHandle = uint32_t;
+		using ExecuteCallback = std::function<void()>;
 		static constexpr ResourceHandle InvalidResource = UINT32_MAX;
 
+		enum class PassFlags : uint32_t
+		{
+			None = 0,
+			Graphics = BIT(0),
+			Compute = BIT(1),
+			Transfer = BIT(2),
+			SideEffect = BIT(3),
+			NeverCull = BIT(4)
+		};
+
 		struct TextureDesc
 		{
 			std::string Name;
@@ -34,6 +46,8 @@ namespace Lux {
 			std::string Name;
 			std::vector<ResourceHandle> Reads;
 			std::vector<ResourceHandle> Writes;
+			PassFlags Flags = PassFlags::None;
+			ExecuteCallback Execute;
 		};
 
 		struct ResourceLifetime
@@ -44,16 +58,41 @@ namespace Lux {
 			uint32_t AliasIndex = UINT32_MAX;
 		};
 
+		struct CompileResult
+		{
+			std::vector<ResourceLifetime> Lifetimes;
+			std::vector<uint32_t> ExecutionOrder;
+			std::vector<uint32_t> CulledPasses;
+			std::vector<std::string> Diagnostics;
+			bool Valid = true;
+		};
+
 		void Reset();
 		ResourceHandle AddTransientTexture(const TextureDesc& desc);
-		uint32_t AddPass(const PassDesc& desc);
+		uint32_t AddPass(PassDesc desc);
+		uint32_t AddPass(PassDesc desc, ExecuteCallback execute);
+		CompileResult Compile() const;
+		CompileResult Execute() const;
+		void Execute(const CompileResult& compileResult) const;
 		std::vector<ResourceLifetime> BuildAliasPlan() const;
 
 		const std::vector<TextureDesc>& GetTextures() const { return m_Textures; }
 		const std::vector<PassDesc>& GetPasses() const { return m_Passes; }
 
+		static constexpr PassFlags CombineFlags(PassFlags lhs, PassFlags rhs)
+		{
+			return static_cast<PassFlags>(static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+		}
+
+		static constexpr bool HasFlag(PassFlags flags, PassFlags flag)
+		{
+			return (static_cast<uint32_t>(flags) & static_cast<uint32_t>(flag)) != 0;
+		}
+
 	private:
 		static bool AreAliasCompatible(const TextureDesc& lhs, const TextureDesc& rhs);
+		static void NormalizeResourceList(std::vector<ResourceHandle>& resources);
+		std::vector<ResourceLifetime> BuildResourceLifetimes(std::vector<std::string>* diagnostics = nullptr) const;
 
 		std::vector<TextureDesc> m_Textures;
 		std::vector<PassDesc> m_Passes;