From a2a0e6bd54862cb51e69fc27c0339bda9ff8cb4d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Leclercq?= <lynix680@gmail.com>
Date: Tue, 10 Aug 2021 10:36:16 +0200
Subject: [PATCH] Graphics: Add DepthMaterial

---
 examples/PhysicsDemo/main.cpp                 |  11 +-
 include/Nazara/Graphics.hpp                   |   1 +
 include/Nazara/Graphics/BasicMaterial.hpp     |   9 +-
 include/Nazara/Graphics/DepthMaterial.hpp     |  38 +++++
 include/Nazara/Graphics/DepthMaterial.inl     |  16 +++
 include/Nazara/Graphics/MaterialSettings.hpp  |   5 +-
 include/Nazara/Graphics/MaterialSettings.inl  |  26 ++++
 src/Nazara/Graphics/BasicMaterial.cpp         | 130 ++++++++++--------
 src/Nazara/Graphics/DepthMaterial.cpp         |  44 ++++++
 src/Nazara/Graphics/MaterialPipeline.cpp      |   3 +
 .../Resources/Shaders/depth_material.nzsl     |   3 +-
 11 files changed, 213 insertions(+), 73 deletions(-)
 create mode 100644 include/Nazara/Graphics/DepthMaterial.hpp
 create mode 100644 include/Nazara/Graphics/DepthMaterial.inl
 create mode 100644 src/Nazara/Graphics/DepthMaterial.cpp
 rename bin/resources/depth_pass.nzsl => src/Nazara/Graphics/Resources/Shaders/depth_material.nzsl (94%)

diff --git a/examples/PhysicsDemo/main.cpp b/examples/PhysicsDemo/main.cpp
index 8b5ec3efd..0fee85707 100644
--- a/examples/PhysicsDemo/main.cpp
+++ b/examples/PhysicsDemo/main.cpp
@@ -77,14 +77,9 @@ int main()
 
 	std::shared_ptr<Nz::Material> material = std::make_shared<Nz::Material>();
 
-	auto customSettings = Nz::BasicMaterial::GetSettings()->GetBuilderData();
-	customSettings.shaders.clear();
-	customSettings.shaders.emplace_back(std::make_shared<Nz::UberShader>(Nz::ShaderStageType::Fragment | Nz::ShaderStageType::Vertex, Nz::ShaderLang::Parse(resourceDir / "depth_pass.nzsl")));
-
-	auto depthSettings = std::make_shared<Nz::MaterialSettings>(std::move(customSettings));
-
-	std::shared_ptr<Nz::MaterialPass> depthPass = std::make_shared<Nz::MaterialPass>(depthSettings);
+	std::shared_ptr<Nz::MaterialPass> depthPass = std::make_shared<Nz::MaterialPass>(Nz::DepthMaterial::GetSettings());
 	depthPass->EnableDepthBuffer(true);
+	depthPass->EnableDepthClamp(true);
 	depthPass->EnableFaceCulling(true);
 
 	std::shared_ptr<Nz::MaterialPass> materialPass = std::make_shared<Nz::MaterialPass>(Nz::BasicMaterial::GetSettings());
@@ -104,7 +99,7 @@ int main()
 	basicMat.SetDiffuseMap(Nz::Texture::LoadFromFile(resourceDir / "Spaceship/Texture/diffuse.png", texParams));
 	basicMat.SetDiffuseSampler(samplerInfo);
 
-	Nz::BasicMaterial basicMatDepth(*depthPass);
+	Nz::DepthMaterial basicMatDepth(*depthPass);
 	basicMatDepth.SetAlphaMap(Nz::Texture::LoadFromFile(resourceDir / "alphatile.png", texParams));
 
 	std::shared_ptr<Nz::Model> model = std::make_shared<Nz::Model>(std::move(gfxMesh));
diff --git a/include/Nazara/Graphics.hpp b/include/Nazara/Graphics.hpp
index 78a68da9c..0bfeb7b60 100644
--- a/include/Nazara/Graphics.hpp
+++ b/include/Nazara/Graphics.hpp
@@ -35,6 +35,7 @@
 #include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Graphics/Config.hpp>
 #include <Nazara/Graphics/CullingList.hpp>
+#include <Nazara/Graphics/DepthMaterial.hpp>
 #include <Nazara/Graphics/ElementRenderer.hpp>
 #include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Graphics/ForwardFramePipeline.hpp>
diff --git a/include/Nazara/Graphics/BasicMaterial.hpp b/include/Nazara/Graphics/BasicMaterial.hpp
index 4e2d27022..99acdf8c1 100644
--- a/include/Nazara/Graphics/BasicMaterial.hpp
+++ b/include/Nazara/Graphics/BasicMaterial.hpp
@@ -12,6 +12,8 @@
 
 namespace Nz
 {
+	class FieldOffsets;
+
 	class NAZARA_GRAPHICS_API BasicMaterial
 	{
 		friend class MaterialPipeline;
@@ -56,7 +58,7 @@ namespace Nz
 				std::size_t totalSize;
 			};
 
-		private:
+		protected:
 			struct OptionIndexes
 			{
 				std::size_t alphaTest;
@@ -70,6 +72,11 @@ namespace Nz
 				std::size_t diffuse;
 			};
 
+			static MaterialSettings::Builder Build(const UniformOffsets& offsets, std::vector<UInt8> defaultValues, std::vector<std::shared_ptr<UberShader>> uberShaders, std::size_t* uniformBlockIndex = nullptr, OptionIndexes* optionIndexes = nullptr, TextureIndexes* textureIndexes = nullptr);
+			static std::vector<std::shared_ptr<UberShader>> BuildShaders();
+			static std::pair<UniformOffsets, FieldOffsets> BuildUniformOffsets();
+
+		private:
 			static bool Initialize();
 			static void Uninitialize();
 
diff --git a/include/Nazara/Graphics/DepthMaterial.hpp b/include/Nazara/Graphics/DepthMaterial.hpp
new file mode 100644
index 000000000..7cb95be45
--- /dev/null
+++ b/include/Nazara/Graphics/DepthMaterial.hpp
@@ -0,0 +1,38 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_DEPTH_MATERIAL_HPP
+#define NAZARA_DEPTH_MATERIAL_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Graphics/BasicMaterial.hpp>
+
+namespace Nz
+{
+	class NAZARA_GRAPHICS_API DepthMaterial : public BasicMaterial
+	{
+		friend class MaterialPipeline;
+
+		public:
+			using BasicMaterial::BasicMaterial;
+			~DepthMaterial() = default;
+
+			static inline const std::shared_ptr<MaterialSettings>& GetSettings();
+
+		protected:
+			static std::vector<std::shared_ptr<UberShader>> BuildShaders();
+
+		private:
+			static bool Initialize();
+			static void Uninitialize();
+
+			static std::shared_ptr<MaterialSettings> s_materialSettings;
+	};
+}
+
+#include <Nazara/Graphics/DepthMaterial.inl>
+
+#endif
diff --git a/include/Nazara/Graphics/DepthMaterial.inl b/include/Nazara/Graphics/DepthMaterial.inl
new file mode 100644
index 000000000..9807b660f
--- /dev/null
+++ b/include/Nazara/Graphics/DepthMaterial.inl
@@ -0,0 +1,16 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/DepthMaterial.hpp>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	inline const std::shared_ptr<MaterialSettings>& DepthMaterial::GetSettings()
+	{
+		return s_materialSettings;
+	}
+}
+
+#include <Nazara/Graphics/DebugOff.hpp>
diff --git a/include/Nazara/Graphics/MaterialSettings.hpp b/include/Nazara/Graphics/MaterialSettings.hpp
index 98955f976..6f06f83cf 100644
--- a/include/Nazara/Graphics/MaterialSettings.hpp
+++ b/include/Nazara/Graphics/MaterialSettings.hpp
@@ -9,6 +9,7 @@
 
 #include <Nazara/Prerequisites.hpp>
 #include <Nazara/Graphics/Enums.hpp>
+#include <Nazara/Graphics/UberShader.hpp>
 #include <Nazara/Renderer/RenderPipelineLayout.hpp>
 #include <Nazara/Renderer/ShaderModule.hpp>
 #include <Nazara/Utility/Enums.hpp>
@@ -19,8 +20,6 @@
 
 namespace Nz
 {
-	class UberShader;
-
 	class MaterialSettings
 	{
 		public:
@@ -56,6 +55,8 @@ namespace Nz
 
 			static constexpr std::size_t InvalidIndex = std::numeric_limits<std::size_t>::max();
 
+			static void BuildOption(std::vector<Option>& options, const std::vector<std::shared_ptr<UberShader>>& uberShaders, std::string optionName, const std::string& shaderOptionName);
+
 			struct Builder
 			{
 				std::vector<std::shared_ptr<UberShader>> shaders;
diff --git a/include/Nazara/Graphics/MaterialSettings.inl b/include/Nazara/Graphics/MaterialSettings.inl
index 33ae27b58..0a9a1eecc 100644
--- a/include/Nazara/Graphics/MaterialSettings.inl
+++ b/include/Nazara/Graphics/MaterialSettings.inl
@@ -165,6 +165,32 @@ namespace Nz
 
 		return InvalidIndex;
 	}
+
+	inline void MaterialSettings::BuildOption(std::vector<Option>& options, const std::vector<std::shared_ptr<UberShader>>& uberShaders, std::string optionName, const std::string& shaderOptionName)
+	{
+		std::array<UInt64, ShaderStageTypeCount> shaderOptions;
+		shaderOptions.fill(0);
+
+		for (std::size_t i = 0; i < ShaderStageTypeCount; ++i)
+		{
+			for (const auto& uberShader : uberShaders)
+			{
+				if (uberShader->GetSupportedStages() & static_cast<ShaderStageType>(i))
+				{
+					assert(shaderOptions[i] == 0);
+					shaderOptions[i] |= uberShader->GetOptionFlagByName(shaderOptionName);
+				}
+			}
+		}
+
+		if (std::any_of(shaderOptions.begin(), shaderOptions.end(), [&](UInt64 flags) { return flags != 0; }))
+		{
+			options.push_back({
+				std::move(optionName),
+				shaderOptions
+			});
+		}
+	}
 }
 
 #include <Nazara/Graphics/DebugOff.hpp>
diff --git a/src/Nazara/Graphics/BasicMaterial.cpp b/src/Nazara/Graphics/BasicMaterial.cpp
index 4702c03a9..89a67ca5a 100644
--- a/src/Nazara/Graphics/BasicMaterial.cpp
+++ b/src/Nazara/Graphics/BasicMaterial.cpp
@@ -94,107 +94,115 @@ namespace Nz
 		colorPtr[3] = diffuse.a / 255.f;
 	}
 
-	bool BasicMaterial::Initialize()
+	MaterialSettings::Builder BasicMaterial::Build(const UniformOffsets& offsets, std::vector<UInt8> defaultValues, std::vector<std::shared_ptr<UberShader>> uberShaders, std::size_t* uniformBlockIndex, OptionIndexes* optionIndexes, TextureIndexes* textureIndexes)
 	{
-		FieldOffsets fieldOffsets(StructLayout::Std140);
-
-		s_uniformOffsets.alphaThreshold = fieldOffsets.AddField(StructFieldType::Float1);
-		s_uniformOffsets.diffuseColor = fieldOffsets.AddField(StructFieldType::Float4);
-		s_uniformOffsets.totalSize = fieldOffsets.GetSize();
-
 		MaterialSettings::Builder settings;
 
 		std::vector<MaterialSettings::UniformVariable> variables;
-		variables.assign({
-			{
+		if (offsets.alphaThreshold != std::numeric_limits<std::size_t>::max())
+		{
+			variables.push_back({
 				"AlphaThreshold",
-				s_uniformOffsets.alphaThreshold
-			},
-			{
+				offsets.alphaThreshold
+			});
+		}
+
+		if (offsets.diffuseColor != std::numeric_limits<std::size_t>::max())
+		{
+			variables.push_back({
 				"DiffuseColor",
-				s_uniformOffsets.diffuseColor
-			}
-		});
+				offsets.diffuseColor
+			});
+		}
+
+		if (offsets.alphaThreshold != std::numeric_limits<std::size_t>::max())
+			AccessByOffset<float&>(defaultValues.data(), offsets.alphaThreshold) = 0.2f;
 
 		static_assert(sizeof(Vector4f) == 4 * sizeof(float), "Vector4f is expected to be exactly 4 floats wide");
+		if (offsets.diffuseColor != std::numeric_limits<std::size_t>::max())
+			AccessByOffset<Vector4f&>(defaultValues.data(), offsets.diffuseColor) = Vector4f(1.f, 1.f, 1.f, 1.f);
+
+		// Textures
+		if (textureIndexes)
+			textureIndexes->alpha = settings.textures.size();
 
-		std::vector<UInt8> defaultValues(fieldOffsets.GetSize());
-		AccessByOffset<Vector4f&>(defaultValues.data(), s_uniformOffsets.diffuseColor) = Vector4f(1.f, 1.f, 1.f, 1.f);
-		AccessByOffset<float&>(defaultValues.data(), s_uniformOffsets.alphaThreshold) = 0.2f;
-		
-		s_textureIndexes.alpha = settings.textures.size();
 		settings.textures.push_back({
 			2,
 			"Alpha",
 			ImageType::E2D
 		});
 
-		s_textureIndexes.diffuse = settings.textures.size();
+		if (textureIndexes)
+			textureIndexes->diffuse = settings.textures.size();
+
 		settings.textures.push_back({
 			1,
 			"Diffuse",
 			ImageType::E2D
 		});
 
-		s_uniformBlockIndex = settings.uniformBlocks.size();
+		if (uniformBlockIndex)
+			*uniformBlockIndex = settings.uniformBlocks.size();
+
 		settings.uniformBlocks.push_back({
 			0,
 			"BasicSettings",
-			fieldOffsets.GetSize(),
+			offsets.totalSize,
 			std::move(variables),
 			std::move(defaultValues)
 		});
 
-		// Shaders
-		ShaderAst::StatementPtr shaderAst = ShaderLang::Parse(std::string_view(reinterpret_cast<const char*>(r_shader), sizeof(r_shader)));
-		auto uberShader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, shaderAst);
-
-		settings.shaders.emplace_back(uberShader);
+		settings.shaders = std::move(uberShaders);
 
 		// Options
 
 		// HasDiffuseMap
-		{
-			std::array<UInt64, ShaderStageTypeCount> shaderOptions;
-			shaderOptions.fill(0);
-			shaderOptions[UnderlyingCast(ShaderStageType::Fragment)] = uberShader->GetOptionFlagByName("HAS_DIFFUSE_TEXTURE");
-			shaderOptions[UnderlyingCast(ShaderStageType::Vertex)] = uberShader->GetOptionFlagByName("HAS_DIFFUSE_TEXTURE");
+		if (optionIndexes)
+			optionIndexes->hasDiffuseMap = settings.options.size();
 
-			s_optionIndexes.hasDiffuseMap = settings.options.size();
-			settings.options.push_back({
-				"HasDiffuseMap",
-				shaderOptions
-			});
-		}
+		MaterialSettings::BuildOption(settings.options, settings.shaders, "HasDiffuseMap", "HAS_DIFFUSE_TEXTURE");
 
 		// HasAlphaMap
-		{
-			std::array<UInt64, ShaderStageTypeCount> shaderOptions;
-			shaderOptions.fill(0);
-			shaderOptions[UnderlyingCast(ShaderStageType::Fragment)] = uberShader->GetOptionFlagByName("HAS_ALPHA_TEXTURE");
-			shaderOptions[UnderlyingCast(ShaderStageType::Vertex)] = uberShader->GetOptionFlagByName("HAS_ALPHA_TEXTURE");
+		if (optionIndexes)
+			optionIndexes->hasAlphaMap = settings.options.size();
 
-			s_optionIndexes.hasAlphaMap = settings.options.size();
-			settings.options.push_back({
-				"HasAlphaMap",
-				shaderOptions
-			});
-		}
+		MaterialSettings::BuildOption(settings.options, settings.shaders, "HasAlphaMap", "HAS_ALPHA_TEXTURE");
 
 		// AlphaTest
-		{
-			std::array<UInt64, ShaderStageTypeCount> shaderOptions;
-			shaderOptions.fill(0);
-			shaderOptions[UnderlyingCast(ShaderStageType::Fragment)] = uberShader->GetOptionFlagByName("ALPHA_TEST");
+		if (optionIndexes)
+			optionIndexes->alphaTest = settings.options.size();
 
-			s_optionIndexes.alphaTest = settings.options.size();
-			settings.options.push_back({
-				"AlphaTest",
-				shaderOptions
-			});
-		}
+		MaterialSettings::BuildOption(settings.options, settings.shaders, "AlphaTest", "ALPHA_TEST");
 
-		s_materialSettings = std::make_shared<MaterialSettings>(std::move(settings));
+		return settings;
+	}
+
+	std::vector<std::shared_ptr<UberShader>> BasicMaterial::BuildShaders()
+	{
+		ShaderAst::StatementPtr shaderAst = ShaderLang::Parse(std::string_view(reinterpret_cast<const char*>(r_shader), sizeof(r_shader)));
+		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, shaderAst);
+
+		return { std::move(shader) };
+	}
+
+	auto BasicMaterial::BuildUniformOffsets() -> std::pair<UniformOffsets, FieldOffsets>
+	{
+		FieldOffsets fieldOffsets(StructLayout::Std140);
+
+		UniformOffsets uniformOffsets;
+		uniformOffsets.alphaThreshold = fieldOffsets.AddField(StructFieldType::Float1);
+		uniformOffsets.diffuseColor = fieldOffsets.AddField(StructFieldType::Float4);
+		uniformOffsets.totalSize = fieldOffsets.GetSize();
+
+		return std::make_pair(std::move(uniformOffsets), std::move(fieldOffsets));
+	}
+
+	bool BasicMaterial::Initialize()
+	{
+		std::tie(s_uniformOffsets, std::ignore) = BuildUniformOffsets();
+
+		std::vector<UInt8> defaultValues(s_uniformOffsets.totalSize);
+		s_materialSettings = std::make_shared<MaterialSettings>(Build(s_uniformOffsets, std::move(defaultValues), BuildShaders(), &s_uniformBlockIndex, &s_optionIndexes, &s_textureIndexes));
 
 		return true;
 	}
diff --git a/src/Nazara/Graphics/DepthMaterial.cpp b/src/Nazara/Graphics/DepthMaterial.cpp
new file mode 100644
index 000000000..b81edcb01
--- /dev/null
+++ b/src/Nazara/Graphics/DepthMaterial.cpp
@@ -0,0 +1,44 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/DepthMaterial.hpp>
+#include <Nazara/Shader/ShaderLangParser.hpp>
+#include <Nazara/Utility/FieldOffsets.hpp>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	namespace
+	{
+		const UInt8 r_shader[] = {
+			#include <Nazara/Graphics/Resources/Shaders/depth_material.nzsl.h>
+		};
+	}
+
+	std::vector<std::shared_ptr<UberShader>> DepthMaterial::BuildShaders()
+	{
+		ShaderAst::StatementPtr shaderAst = ShaderLang::Parse(std::string_view(reinterpret_cast<const char*>(r_shader), sizeof(r_shader)));
+		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, shaderAst);
+
+		return { std::move(shader) };
+	}
+
+	bool DepthMaterial::Initialize()
+	{
+		UniformOffsets offsets;
+		std::tie(offsets, std::ignore) = BuildUniformOffsets();
+
+		std::vector<UInt8> defaultValues(offsets.totalSize);
+		s_materialSettings = std::make_shared<MaterialSettings>(Build(offsets, std::move(defaultValues), BuildShaders()));
+
+		return true;
+	}
+
+	void DepthMaterial::Uninitialize()
+	{
+		s_materialSettings.reset();
+	}
+
+	std::shared_ptr<MaterialSettings> DepthMaterial::s_materialSettings;
+}
diff --git a/src/Nazara/Graphics/MaterialPipeline.cpp b/src/Nazara/Graphics/MaterialPipeline.cpp
index c2a1899dd..edab00316 100644
--- a/src/Nazara/Graphics/MaterialPipeline.cpp
+++ b/src/Nazara/Graphics/MaterialPipeline.cpp
@@ -6,6 +6,7 @@
 #include <Nazara/Core/File.hpp>
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Graphics/BasicMaterial.hpp>
+#include <Nazara/Graphics/DepthMaterial.hpp>
 #include <Nazara/Graphics/MaterialPass.hpp>
 #include <Nazara/Graphics/MaterialSettings.hpp>
 #include <Nazara/Graphics/PhongLightingMaterial.hpp>
@@ -78,6 +79,7 @@ namespace Nz
 	bool MaterialPipeline::Initialize()
 	{
 		BasicMaterial::Initialize();
+		DepthMaterial::Initialize();
 		PhongLightingMaterial::Initialize();
 
 		return true;
@@ -87,6 +89,7 @@ namespace Nz
 	{
 		s_pipelineCache.clear();
 		PhongLightingMaterial::Uninitialize();
+		DepthMaterial::Uninitialize();
 		BasicMaterial::Uninitialize();
 	}
 
diff --git a/bin/resources/depth_pass.nzsl b/src/Nazara/Graphics/Resources/Shaders/depth_material.nzsl
similarity index 94%
rename from bin/resources/depth_pass.nzsl
rename to src/Nazara/Graphics/Resources/Shaders/depth_material.nzsl
index c15edf127..8c2fa70c1 100644
--- a/bin/resources/depth_pass.nzsl
+++ b/src/Nazara/Graphics/Resources/Shaders/depth_material.nzsl
@@ -38,6 +38,7 @@ external
 	[set(1), binding(0)] instanceData: uniform<InstanceData>,
 	[set(2), binding(0)] settings: uniform<BasicSettings>,
 	[set(2), binding(2)] MaterialAlphaMap: sampler2D<f32>,
+	[set(2), binding(1)] MaterialDiffuseMap: sampler2D<f32>
 }
 
 // Fragment stage
@@ -58,11 +59,11 @@ fn main(input: FragIn)
 		// TODO: alpha *= MaterialAlphaMap.Sample(input.uv).x
 		alpha = alpha * MaterialAlphaMap.Sample(input.uv).x;
 
-	// TODO: const assert?
 	if (alpha < settings.AlphaThreshold)
 		discard;
 }
 
+// Dummy fragment shader (TODO: Add a way to delete stage?)
 [entry(frag), cond(!ALPHA_TEST)]
 fn main() {}