Add support for shader hotreloading

src/Nazara/Graphics/BasicMaterial.cpp

@@ -229,8 +229,7 @@ namespace Nz
 
 	std::vector<std::shared_ptr<UberShader>> BasicMaterial::BuildShaders()
 	{
-		ShaderAst::ModulePtr shaderModule = Graphics::Instance()->GetShaderModuleResolver()->Resolve("BasicMaterial");
-		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, std::move(shaderModule));
+		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, "BasicMaterial");
 
 		return { std::move(shader) };
 	}

src/Nazara/Graphics/DepthMaterial.cpp

@@ -11,8 +11,7 @@ namespace Nz
 {
 	std::vector<std::shared_ptr<UberShader>> DepthMaterial::BuildShaders()
 	{
-		ShaderAst::ModulePtr shaderModule = Graphics::Instance()->GetShaderModuleResolver()->Resolve("DepthMaterial");
-		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, std::move(shaderModule));
+		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, "DepthMaterial");
 
 		return { std::move(shader) };
 	}

src/Nazara/Graphics/MaterialPass.cpp

@@ -33,10 +33,17 @@ namespace Nz
 		m_pipelineInfo.settings = m_settings;
 
 		const auto& shaders = m_settings->GetShaders();
-		for (const auto& shader : shaders)
+
+		m_shaders.resize(shaders.size());
+		for (std::size_t i = 0; i < m_shaders.size(); ++i)
 		{
 			auto& shaderData = m_pipelineInfo.shaders.emplace_back();
-			shaderData.uberShader = shader;
+			shaderData.uberShader = shaders[i];
+
+			m_shaders[i].onShaderUpdated.Connect(shaders[i]->OnShaderUpdated, [this](UberShader*)
+			{
+				InvalidatePipeline();
+			});
 		}
 
 		const auto& textureSettings = m_settings->GetTextures();

src/Nazara/Graphics/PhongLightingMaterial.cpp

@@ -310,8 +310,7 @@ namespace Nz
 
 	std::vector<std::shared_ptr<UberShader>> PhongLightingMaterial::BuildShaders()
 	{
-		ShaderAst::ModulePtr shaderModule = Graphics::Instance()->GetShaderModuleResolver()->Resolve("PhongMaterial");
-		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, std::move(shaderModule));
+		auto shader = std::make_shared<UberShader>(ShaderStageType::Fragment | ShaderStageType::Vertex, "PhongMaterial");
 
 		return { std::move(shader) };
 	}

src/Nazara/Graphics/UberShader.cpp

@@ -3,6 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/UberShader.hpp>
+#include <Nazara/Core/Error.hpp>
 #include <Nazara/Graphics/Graphics.hpp>
 #include <Nazara/Renderer/RenderDevice.hpp>
 #include <Nazara/Shader/Ast/AstReflect.hpp>
@@ -13,13 +14,81 @@
 
 namespace Nz
 {
+	UberShader::UberShader(ShaderStageTypeFlags shaderStages, std::string moduleName) :
+	UberShader(shaderStages, *Graphics::Instance()->GetShaderModuleResolver(), std::move(moduleName))
+	{
+	}
+
+	UberShader::UberShader(ShaderStageTypeFlags shaderStages, ShaderModuleResolver& moduleResolver, std::string moduleName) :
+	m_shaderStages(shaderStages)
+	{
+		m_shaderModule = moduleResolver.Resolve(moduleName);
+		NazaraAssert(m_shaderModule, "invalid shader module");
+
+		Validate(*m_shaderModule);
+
+		m_onShaderModuleUpdated.Connect(moduleResolver.OnModuleUpdated, [this, name = std::move(moduleName)](ShaderModuleResolver* resolver, const std::string& updatedModuleName)
+		{
+			if (updatedModuleName != name)
+				return;
+
+			ShaderAst::ModulePtr newShaderModule = resolver->Resolve(name);
+			if (!newShaderModule)
+			{
+				NazaraError("failed to retrieve updated shader module " + name);
+				return;
+			}
+
+			try
+			{
+				// FIXME: Validate is destructive, in case of failure it can invalidate the shader
+				Validate(*newShaderModule);
+			}
+			catch (const std::exception& e)
+			{
+				NazaraError("failed to retrieve updated shader module " + name + ": " + e.what());
+				return;
+			}
+
+			m_shaderModule = std::move(newShaderModule);
+
+			// Clear cache
+			m_combinations.clear();
+
+			OnShaderUpdated(this);
+		});
+	}
+
 	UberShader::UberShader(ShaderStageTypeFlags shaderStages, ShaderAst::ModulePtr shaderModule) :
 	m_shaderModule(std::move(shaderModule)),
 	m_shaderStages(shaderStages)
 	{
-		NazaraAssert(m_shaderStages != 0, "there must be at least one shader stage");
 		NazaraAssert(m_shaderModule, "invalid shader module");
 
+		Validate(*m_shaderModule);
+	}
+
+	const std::shared_ptr<ShaderModule>& UberShader::Get(const Config& config)
+	{
+		auto it = m_combinations.find(config);
+		if (it == m_combinations.end())
+		{
+			ShaderWriter::States states;
+			states.optionValues = config.optionValues;
+			states.shaderModuleResolver = Graphics::Instance()->GetShaderModuleResolver();
+
+			std::shared_ptr<ShaderModule> stage = Graphics::Instance()->GetRenderDevice()->InstantiateShaderModule(m_shaderStages, *m_shaderModule, std::move(states));
+
+			it = m_combinations.emplace(config, std::move(stage)).first;
+		}
+
+		return it->second;
+	}
+
+	void UberShader::Validate(ShaderAst::Module& module)
+	{
+		NazaraAssert(m_shaderStages != 0, "there must be at least one shader stage");
+
 		//TODO: Try to partially sanitize shader?
 
 		std::size_t optionCount = 0;
@@ -44,26 +113,9 @@ namespace Nz
 		};
 
 		ShaderAst::AstReflect reflect;
-		reflect.Reflect(*m_shaderModule->rootNode, callbacks);
+		reflect.Reflect(*module.rootNode, callbacks);
 
 		if ((m_shaderStages & supportedStageType) != m_shaderStages)
 			throw std::runtime_error("shader doesn't support all required shader stages");
 	}
-
-	const std::shared_ptr<ShaderModule>& UberShader::Get(const Config& config)
-	{
-		auto it = m_combinations.find(config);
-		if (it == m_combinations.end())
-		{
-			ShaderWriter::States states;
-			states.optionValues = config.optionValues;
-			states.shaderModuleResolver = Graphics::Instance()->GetShaderModuleResolver();
-
-			std::shared_ptr<ShaderModule> stage = Graphics::Instance()->GetRenderDevice()->InstantiateShaderModule(m_shaderStages, *m_shaderModule, std::move(states));
-
-			it = m_combinations.emplace(config, std::move(stage)).first;
-		}
-
-		return it->second;
-	}
 }

src/Nazara/Shader/FilesystemModuleResolver.cpp

@@ -6,19 +6,44 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/StringExt.hpp>
 #include <Nazara/Shader/ShaderLangParser.hpp>
+#include <efsw/efsw.h>
 #include <cassert>
 #include <Nazara/Shader/Debug.hpp>
 
 namespace Nz
 {
+	FilesystemModuleResolver::FilesystemModuleResolver()
+	{
+		m_fileWatcher = efsw_create(0);
+		efsw_watch(m_fileWatcher);
+	}
+
+	FilesystemModuleResolver::~FilesystemModuleResolver()
+	{
+		if (m_fileWatcher)
+			efsw_release(m_fileWatcher);
+	}
+
 	void FilesystemModuleResolver::RegisterModule(const std::filesystem::path& realPath)
 	{
-		return RegisterModule(ShaderLang::ParseFromFile(realPath));
+		ShaderAst::ModulePtr module = ShaderLang::ParseFromFile(realPath);
+		if (!module)
+			return;
+
+		std::string moduleName = module->metadata->moduleName;
+		RegisterModule(std::move(module));
+
+		std::filesystem::path canonicalPath = std::filesystem::canonical(realPath);
+		m_moduleByFilepath.emplace(canonicalPath.generic_u8string(), std::move(moduleName));
 	}
 
 	void FilesystemModuleResolver::RegisterModule(std::string_view moduleSource)
 	{
-		return RegisterModule(ShaderLang::Parse(moduleSource));
+		ShaderAst::ModulePtr module = ShaderLang::Parse(moduleSource);
+		if (!module)
+			return;
+
+		return RegisterModule(std::move(module));
 	}
 
 	void FilesystemModuleResolver::RegisterModule(ShaderAst::ModulePtr module)
@@ -29,14 +54,52 @@ namespace Nz
 		if (moduleName.empty())
 			throw std::runtime_error("cannot register anonymous module");
 
-		m_modules.insert_or_assign(std::move(moduleName), std::move(module));
+		auto it = m_modules.find(moduleName);
+		if (it != m_modules.end())
+		{
+			it->second = std::move(module);
+
+			OnModuleUpdated(this, moduleName);
+		}
+		else
+			m_modules.emplace(std::move(moduleName), std::move(module));
 	}
 
-	void FilesystemModuleResolver::RegisterModuleDirectory(const std::filesystem::path& realPath)
+	void FilesystemModuleResolver::RegisterModuleDirectory(const std::filesystem::path& realPath, bool watchDirectory)
 	{
+		if (!std::filesystem::is_directory(realPath))
+			return;
+
+		auto FileSystemCallback = [](efsw_watcher /*watcher*/, efsw_watchid /*watchid*/, const char* dir, const char* filename, efsw_action action, const char* oldFileName, void* param)
+		{
+			FilesystemModuleResolver* resolver = static_cast<FilesystemModuleResolver*>(param);
+
+			switch (action)
+			{
+				case EFSW_ADD:
+					resolver->OnFileAdded(dir, filename);
+					break;
+
+				case EFSW_DELETE:
+					resolver->OnFileRemoved(dir, filename);
+					break;
+
+				case EFSW_MODIFIED:
+					resolver->OnFileUpdated(dir, filename);
+					break;
+
+				case EFSW_MOVED:
+					resolver->OnFileMoved(dir, filename, (oldFileName) ? oldFileName : std::string_view());
+					break;
+			}
+		};
+
+		if (watchDirectory)
+			efsw_addwatch(m_fileWatcher, realPath.generic_u8string().c_str(), FileSystemCallback, 1, this);
+
 		for (const auto& entry : std::filesystem::recursive_directory_iterator(realPath))
 		{
-			if (entry.is_regular_file() && StringEqual(entry.path().extension().generic_u8string(), ".nzsl", Nz::CaseIndependent{}))
+			if (entry.is_regular_file() && StringEqual(entry.path().extension().generic_u8string(), ModuleExtension, Nz::CaseIndependent{}))
 			{
 				try
 				{
@@ -58,4 +121,53 @@ namespace Nz
 
 		return it->second;
 	}
+
+	void FilesystemModuleResolver::OnFileAdded(std::string_view directory, std::string_view filename)
+	{
+		if (!EndsWith(filename, ModuleExtension))
+			return;
+
+		RegisterModule(std::filesystem::path(directory) / filename);
+	}
+
+	void FilesystemModuleResolver::OnFileRemoved(std::string_view directory, std::string_view filename)
+	{
+		if (!EndsWith(filename, ModuleExtension))
+			return;
+
+		std::filesystem::path canonicalPath = std::filesystem::canonical(std::filesystem::path(directory) / filename);
+
+		auto it = m_moduleByFilepath.find(canonicalPath.generic_u8string());
+		if (it != m_moduleByFilepath.end())
+		{
+			m_modules.erase(it->second);
+			m_moduleByFilepath.erase(it);
+		}
+	}
+
+	void FilesystemModuleResolver::OnFileMoved(std::string_view directory, std::string_view filename, std::string_view oldFilename)
+	{
+		if (oldFilename.empty() || !EndsWith(oldFilename, ModuleExtension))
+			return;
+
+		std::filesystem::path canonicalPath = std::filesystem::canonical(std::filesystem::path(directory) / oldFilename);
+		auto it = m_moduleByFilepath.find(canonicalPath.generic_u8string());
+		if (it != m_moduleByFilepath.end())
+		{
+			std::filesystem::path newCanonicalPath = std::filesystem::canonical(std::filesystem::path(directory) / filename);
+
+			std::string moduleName = std::move(it->second);
+			m_moduleByFilepath.erase(it);
+
+			m_moduleByFilepath.emplace(newCanonicalPath.generic_u8string(), std::move(moduleName));
+		}
+	}
+
+	void FilesystemModuleResolver::OnFileUpdated(std::string_view directory, std::string_view filename)
+	{
+		if (!EndsWith(filename, ModuleExtension))
+			return;
+
+		RegisterModule(std::filesystem::path(directory) / filename);
+	}
 }

src/Nazara/Shader/ShaderLangParser.cpp

@@ -1432,11 +1432,13 @@ namespace Nz::ShaderLang
 		}
 
 		std::size_t length = static_cast<std::size_t>(file.GetSize());
+		if (length == 0)
+			return {};
 
 		std::vector<Nz::UInt8> source(length);
 		if (file.Read(&source[0], length) != length)
 		{
-			NazaraError("Failed to read program file");
+			NazaraError("Failed to read shader file");
 			return {};
 		}