Shader hot compile and reload

Engine/Source/Editor/EditorApp.cpp

@@ -31,7 +31,7 @@
 #include "Rendering/TerrainRenderer.h"
 #include "Rendering/WorldRenderer.h"
 #include "Rendering/ParticleRenderer.h"
-#include "Resources/FileWatcher.hpp"
+#include "Resources/FileWatcher.h"
 #include "Resources/ResourceBuilder.h"
 #include "Resources/ShaderBuilder.h"
 #include "Scene/SceneDatabase.h"
@@ -113,39 +113,7 @@ void EditorApp::Init(engine::EngineInitArgs initArgs)
 	});
 	resourceThread.detach();
 
-#if 0
-	// Test code, will be removed in the next PR.
-	auto FileWatchCallback = [](
-		WatchID id, WatchAction action,
-		const char* rootDir, const char* filePath,
-		const char* oldFilePath, void* user)
-	{
-		switch (action)
-		{
-			case DMON_ACTION_CREATE:
-				CD_FATAL("Create");
-				break;
-
-			case DMON_ACTION_DELETE:
-				CD_FATAL("Delete");
-				break;
-
-			case DMON_ACTION_MODIFY:
-				CD_FATAL("Modify");
-				break;
-
-			case DMON_ACTION_MOVE:
-				CD_FATAL("Move");
-				break;
-
-			default:
-				CD_FATAL("Default");
-		}
-	};
-
-	m_pFileWatcher = std::make_unique<FileWatcher>();
-	m_pFileWatcher->Watch(CDENGINE_BUILTIN_SHADER_PATH, FileWatchCallback, DMON_WATCHFLAGS_RECURSIVE, nullptr);
-#endif
+	InitFileWatcher();
 }
 
 void EditorApp::Shutdown()
@@ -377,6 +345,24 @@ void EditorApp::InitDDGIEntity()
 }
 #endif
 
+void EditorApp::InitFileWatcher()
+{
+	constexpr const char* watchPath = CDENGINE_BUILTIN_SHADER_PATH "shaders/";
+
+	m_pFileWatcher = std::make_unique<FileWatcher>();
+	m_pFileWatcher->SetRenderContext(m_pRenderContext.get());
+	m_pFileWatcher->SetWindow(GetMainWindow());
+	m_pFileWatcher->WatchShaders(watchPath);
+}
+
+void EditorApp::ShaderHotModifyDetec()
+{
+	if (true == m_crtInputFocus)
+	{
+		return;
+	}
+}
+
 void EditorApp::UpdateMaterials()
 {
 	for (engine::Entity entity : m_pSceneWorld->GetMaterialEntities())
@@ -387,20 +373,37 @@ void EditorApp::UpdateMaterials()
 			continue;
 		}
 
-		m_pRenderContext->CheckShaderProgram(pMaterialComponent->GetProgramName(), pMaterialComponent->GetFeaturesCombine());
+		const std::string& programName = pMaterialComponent->GetProgramName();
+		const std::string& featuresCombine = pMaterialComponent->GetFeaturesCombine();
+
+		// New shader feature added, need to compile new variants.
+		m_pRenderContext->CheckShaderProgram(programName, featuresCombine);
+
+		// Shader source files have been modified, need to re-compile existing variants.
+		if (true == m_crtInputFocus && false == m_preInputFocus)
+		{
+			m_pRenderContext->CheckModifiedShaderProgram(programName, featuresCombine);
+		}
+	}
+
+	if (true == m_crtInputFocus && false == m_preInputFocus)
+	{
+		m_pRenderContext->ClearModifiedProgramNameCrcs();
 	}
 }
 
-void EditorApp::LazyCompileAndLoadShaders()
+void EditorApp::RuntimeCompileAndLoadShaders()
 {
 	bool doCompile = false;
 
+	// 1. Compile
 	for (const auto& task : m_pRenderContext->GetShaderCompileTasks())
 	{
 		ShaderBuilder::BuildShader(m_pRenderContext.get(), task);
 		doCompile = true;
 	}
 
+	// 2. Load
 	if (doCompile)
 	{
 		ResourceBuilder::Get().Update(true);
@@ -629,6 +632,7 @@ bool EditorApp::Update(float deltaTime)
 	}
 
 	GetMainWindow()->Update();
+	m_crtInputFocus = GetMainWindow()->GetInputFocus();
 	m_pEditorImGuiContext->Update(deltaTime);
 	m_pSceneWorld->Update();
 
@@ -675,7 +679,7 @@ bool EditorApp::Update(float deltaTime)
 		m_pEngineImGuiContext->Update(deltaTime);
 
 		UpdateMaterials();
-		LazyCompileAndLoadShaders();
+		RuntimeCompileAndLoadShaders();
 
 		for (std::unique_ptr<engine::Renderer>& pRenderer : m_pEngineRenderers)
 		{
@@ -693,6 +697,8 @@ bool EditorApp::Update(float deltaTime)
 
 	engine::Input::Get().FlushInputs();
 
+	m_preInputFocus = m_crtInputFocus;
+
 	return !GetMainWindow()->ShouldClose();
 }
 

Engine/Source/Editor/EditorApp.h

@@ -82,8 +82,13 @@ class EditorApp final : public engine::IApplication
 	void InitDDGIEntity();
 #endif
 
+	void InitFileWatcher();
+	void ShaderHotModifyDetec();
 	void UpdateMaterials();
-	void LazyCompileAndLoadShaders();
+	void RuntimeCompileAndLoadShaders();
+
+	bool m_crtInputFocus = true;
+	bool m_preInputFocus = true;
 
 	bool m_bInitEditor = false;
 	engine::EngineInitArgs m_initArgs;

Engine/Source/Editor/Resources/FileWatcher.cpp

@@ -0,0 +1,135 @@
+#include "FileWatcher.h"
+
+#include "Log/Log.h"
+#include "Path/Path.h"
+#include "Rendering/RenderContext.h"
+#include "Window/Window.h"
+
+#define DMON_LOG_DEBUG(s) do { CD_INFO(s); } while(0)
+#define DMON_LOG_ERROR(s) do { CD_ERROR(s); assert(false); } while(0)
+
+#define DMON_IMPL
+#include "dmon.h"
+
+namespace editor
+{
+
+using WatchID = dmon_watch_id;
+using WatchAction = dmon_action;
+
+class ShaderHotModifyCallbackWrapper final
+{
+public:
+    ShaderHotModifyCallbackWrapper() = default;
+    ShaderHotModifyCallbackWrapper(const ShaderHotModifyCallbackWrapper&) = delete;
+    ShaderHotModifyCallbackWrapper& operator=(const ShaderHotModifyCallbackWrapper&) = delete;
+    ShaderHotModifyCallbackWrapper(ShaderHotModifyCallbackWrapper&&) = delete;
+    ShaderHotModifyCallbackWrapper& operator=(ShaderHotModifyCallbackWrapper&&) = delete;
+    ~ShaderHotModifyCallbackWrapper() = default;
+
+    static void Callback(
+        WatchID id, WatchAction action,
+        const char* rootDir, const char* filePath,
+        const char* oldFilePath, void* user)
+    {
+        switch (action)
+        {
+            case DMON_ACTION_CREATE:
+                CD_TRACE("New file created");
+                CD_TRACE("    Path : {0}", rootDir);
+                CD_TRACE("    Name : {0}", filePath);
+                break;
+
+            case DMON_ACTION_DELETE:
+                CD_TRACE("File deleted");
+                CD_TRACE("    Path : {0}", rootDir);
+                CD_TRACE("    Name : {0}", filePath);
+                break;
+
+            case DMON_ACTION_MODIFY:
+                CD_TRACE("File Modified");
+                CD_TRACE("    Path : {0}", rootDir);
+                CD_TRACE("    Name : {0}", filePath);
+
+                if (m_pWindow->GetInputFocus() || engine::Path::GetExtension(filePath) != ".sc")
+                {
+                    // Return when window get focus.
+                    // Return when a non-shader file is detected.
+                    return;
+                }
+
+                m_pRenderContext->CheckModifiedProgram(engine::Path::GetFileNameWithoutExtension(filePath));
+
+                break;
+
+            case DMON_ACTION_MOVE:
+                CD_TRACE("File moved");
+                CD_TRACE("    Path : {0}", rootDir);
+                CD_TRACE("    Old Name : {0}", oldFilePath);
+                CD_TRACE("    New Name : {0}", filePath);
+                break;
+
+            default:
+                CD_WARN("Unknown WatchAction!");
+        }
+    }
+
+    static engine::RenderContext* m_pRenderContext;
+    static engine::Window* m_pWindow;
+};
+
+engine::RenderContext* ShaderHotModifyCallbackWrapper::m_pRenderContext = nullptr;
+engine::Window* ShaderHotModifyCallbackWrapper::m_pWindow = nullptr;
+
+FileWatcher::FileWatcher()
+{
+    Init();
+}
+
+FileWatcher::~FileWatcher()
+{
+    Deinit();
+}
+
+void FileWatcher::Init() const
+{
+    dmon_init();
+}
+
+void FileWatcher::Deinit() const
+{
+    dmon_deinit();
+}
+
+uint32_t FileWatcher::WatchShaders(const char* rootDir)
+{
+    ShaderHotModifyCallbackWrapper::m_pRenderContext = m_pRenderContext;
+    ShaderHotModifyCallbackWrapper::m_pWindow = m_pWindow;
+
+    WatchID watchID = dmon_watch(rootDir, ShaderHotModifyCallbackWrapper::Callback, 0, nullptr);
+
+    CD_INFO("Start watching {0}", rootDir);
+    CD_INFO("    Watch ID {0}", watchID.id);
+
+    m_witchInfos[watchID.id] = rootDir;
+
+    return watchID.id;
+}
+
+void FileWatcher::UnWatch(uint32_t watchID)
+{
+    dmon_unwatch(WatchID{ watchID });
+    m_witchInfos.erase(watchID);
+}
+
+void FileWatcher::SetWitchInfos(std::map<uint32_t, const char*> witchInfos)
+{
+    m_witchInfos = cd::MoveTemp(witchInfos);
+}
+
+const char* FileWatcher::GetWatchingPath(uint32_t id) const
+{
+    return m_witchInfos.at(id);
+}
+
+}

Engine/Source/Editor/Resources/FileWatcher.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <cstdint>
+#include <map>
+
+namespace engine
+{
+
+class RenderContext;
+class Window;
+
+}
+
+namespace editor
+{
+
+class FileWatcher final
+{
+
+public:
+    FileWatcher(const FileWatcher&) = delete;
+    FileWatcher& operator=(const FileWatcher&) = delete;
+    FileWatcher(FileWatcher&&) = delete;
+    FileWatcher& operator=(FileWatcher&&) = delete;
+
+    FileWatcher();
+    ~FileWatcher();
+
+    void Init() const;
+    void SetRenderContext(engine::RenderContext* pRenderContext) { m_pRenderContext = pRenderContext; }
+    void SetWindow(engine::Window* pWindow) { m_pWindow = pWindow; }
+    void Deinit() const;
+
+    uint32_t WatchShaders(const char* rootDir);
+    void UnWatch(uint32_t watchID);
+
+    void SetWitchInfos(std::map<uint32_t, const char*>);
+    std::map<uint32_t, const char*>& GetWitchInfos() { return m_witchInfos; }
+    const std::map<uint32_t, const char*>& GetWitchInfos() const { return m_witchInfos; }
+    const char* GetWatchingPath(uint32_t id) const;
+
+private:
+    std::map<uint32_t, const char*> m_witchInfos;
+    engine::RenderContext* m_pRenderContext;
+    engine::Window* m_pWindow;
+};
+
+}