Shader lazy load

.gitignore

@@ -9,11 +9,19 @@ Engine/ThirdPartyProjects
 ARM64
 
 # tmp
-Projects/Shared
+Projects/Shared/*
 Projects/Test/*
 !Projects/Test/*/
 Projects/Test/Textures/*
 !Projects/Test/Textures/*/
 
+# Precompiled Shader
+!Projects/Shared/BuiltInShaders
+Projects/Shared/BuiltInShaders/*
+!Projects/Shared/BuiltInShaders/Direct3D11
+Projects/Shared/BuiltInShaders/Direct3D11/*
+!Projects/Shared/BuiltInShaders/Direct3D11/vs_imgui.bin
+!Projects/Shared/BuiltInShaders/Direct3D11/fs_imgui.bin
+
 # Commercial SKD
 Engine/Auto/commercial_sdk_locations.bat

Engine/Source/Editor/EditorApp.cpp

@@ -91,11 +91,14 @@ void EditorApp::Init(engine::EngineInitArgs initArgs)
 	AddWindow(cd::MoveTemp(pSplashWindow));
 
 	InitEditorRenderers();
+	CreateEditorRendererGraphicsResources();
 	InitEditorImGuiContext(m_initArgs.language);
 
 	InitECWorld();
 	m_pEditorImGuiContext->SetSceneWorld(m_pSceneWorld.get());
 
+	InitEngineRenderers();
+
 	// Add shader build tasks and create a thread to update tasks.
 	InitShaderPrograms();
 	m_pEditorImGuiContext->AddStaticLayer(std::make_unique<Splash>("Splash"));
@@ -107,6 +110,7 @@ void EditorApp::Init(engine::EngineInitArgs initArgs)
 	resourceThread.detach();
 
 	m_pFileWatcher = std::make_unique<FileWatcher>(CDENGINE_BUILTIN_SHADER_PATH);
+	m_pFileWatcher->EnableWatchSubTree();
 }
 
 void EditorApp::Shutdown()
@@ -443,6 +447,22 @@ void EditorApp::InitEngineRenderers()
 	AddEngineRenderer(std::make_unique<engine::ImGuiRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget));
 }
 
+void EditorApp::CreateEditorRendererGraphicsResources()
+{
+	for (std::unique_ptr<engine::Renderer>& pRenderer : m_pEditorRenderers)
+	{
+		pRenderer->CreateGraphicsResources();
+	}
+}
+
+void EditorApp::CreateEngineRendererGraphicsResources()
+{
+	for (std::unique_ptr<engine::Renderer>& pRenderer : m_pEngineRenderers)
+	{
+		pRenderer->CreateGraphicsResources();
+	}
+}
+
 bool EditorApp::IsAtmosphericScatteringEnable() const
 {
 	engine::GraphicsBackend backend = engine::Path::GetGraphicsBackend();
@@ -454,13 +474,10 @@ bool EditorApp::IsAtmosphericScatteringEnable() const
 
 void EditorApp::InitShaderPrograms() const
 {
+	ShaderBuilder::BuildShaders(m_pSceneWorld.get());
+
 	std::string nonUberBuildPath = CDENGINE_BUILTIN_SHADER_PATH;
 	ShaderBuilder::BuildNonUberShader(nonUberBuildPath + "shaders");
-	if (IsAtmosphericScatteringEnable())
-	{
-		std::string atmBuildPath = CDENGINE_BUILTIN_SHADER_PATH;
-		ShaderBuilder::BuildNonUberShader(atmBuildPath + "atm");
-	}
 
 	ShaderBuilder::BuildUberShader(m_pSceneWorld->GetPBRMaterialType());
 	ShaderBuilder::BuildUberShader(m_pSceneWorld->GetAnimationMaterialType());
@@ -498,12 +515,15 @@ bool EditorApp::Update(float deltaTime)
 	if (!m_bInitEditor && ResourceBuilder::Get().IsIdle())
 	{
 		m_bInitEditor = true;
+
 		engine::ShaderLoader::UploadUberShader(m_pSceneWorld->GetPBRMaterialType());
 		engine::ShaderLoader::UploadUberShader(m_pSceneWorld->GetAnimationMaterialType());
 #ifdef ENABLE_DDGI
 		engine::ShaderLoader::UploadUberShader(m_pSceneWorld->GetDDGIMaterialType());
 #endif
 
+		CreateEngineRendererGraphicsResources();
+
 		// Phase 2 - Project Manager
 		//		* TODO : Show project selector
 		//GetMainWindow()->SetTitle("Project Manager");
@@ -521,7 +541,6 @@ bool EditorApp::Update(float deltaTime)
 		GetMainWindow()->SetBordedLess(false);
 		GetMainWindow()->SetResizeable(true);
 
-		InitEngineRenderers();
 		m_pEditorImGuiContext->ClearUILayers();
 		InitEditorUILayers();
 

Engine/Source/Editor/EditorApp.h

@@ -52,6 +52,10 @@ class EditorApp final : public engine::IApplication
 	void InitRenderContext(engine::GraphicsBackend backend, void* hwnd = nullptr);
 	void InitEditorRenderers();
 	void InitEngineRenderers();
+
+	void CreateEditorRendererGraphicsResources();
+	void CreateEngineRendererGraphicsResources();
+
 	void InitShaderPrograms() const;
 	void AddEditorRenderer(std::unique_ptr<engine::Renderer> pRenderer);
 	void AddEngineRenderer(std::unique_ptr<engine::Renderer> pRenderer);

Engine/Source/Editor/Resources/ShaderBuilder.cpp

@@ -1,5 +1,6 @@
 #include "ShaderBuilder.h"
 
+#include "ECWorld/SceneWorld.h"
 #include "Log/Log.h"
 #include "Path/Path.h"
 #include "Rendering/RenderContext.h"
@@ -12,7 +13,7 @@ void ShaderBuilder::BuildUberShader(engine::MaterialType* pMaterialType)
 {
 	engine::ShaderSchema& shaderSchema = pMaterialType->GetShaderSchema();
 
-	// No shader feature support for VS now.
+	// No shader feature supports for VS now.
 	std::string outputVSFilePath = engine::Path::GetShaderOutputPath(shaderSchema.GetVertexShaderPath());
 	ResourceBuilder::Get().AddShaderBuildTask(ShaderType::Vertex,
 		shaderSchema.GetVertexShaderPath(), outputVSFilePath.c_str());
@@ -50,6 +51,25 @@ void ShaderBuilder::BuildNonUberShader(std::string folderPath)
 	}
 }
 
+void ShaderBuilder::BuildShaders(engine::SceneWorld* pSceneWorld)
+{
+	auto* pShaderVariantCollectionsComponent = pSceneWorld->GetShaderVariantCollectionsComponent(pSceneWorld->GetShaderVariantCollectionEntity());
+	const auto& shaderInfos = pShaderVariantCollectionsComponent->GetShaderInformations();
+
+	// for (const auto& info : shaderInfos)
+	// {
+	// 	if (info.second.empty())
+	// 	{
+	// 		// Non-Uber shader case
+	// 		BuildNonUberShader(info.first);
+	// 	}
+	// 	else
+	// 	{
+	// 		// Uber shader case
+	// 	}
+	// }
+}
+
 const ShaderType ShaderBuilder::GetShaderType(const std::string& fileName)
 {
 	if (fileName._Starts_with("vs_") || fileName._Starts_with("VS_"))

Engine/Source/Editor/Resources/ShaderBuilder.h

@@ -6,6 +6,13 @@
 #include <map>
 #include <string>
 
+namespace engine
+{
+
+class SceneWorld;
+
+}
+
 namespace editor
 {
 
@@ -15,6 +22,8 @@ class ShaderBuilder
 	static void BuildNonUberShader(std::string folderPath);
 	static void BuildUberShader(engine::MaterialType* pMaterialType);
 
+	static void BuildShaders(engine::SceneWorld* pSceneWorld);
+
 private:
 	static const ShaderType GetShaderType(const std::string& fileName);
 };

Engine/Source/Runtime/ECWorld/ShaderVariantCollectionsComponent.cpp

@@ -1,8 +1,45 @@
 #include "ShaderVariantCollectionsComponent.h"
 
+#include "Log/Log.h"
+
+#include <cassert>
+
 namespace engine
 {
 
+void ShaderVariantCollectionsComponent::RegisterPragram(std::string programName, ShaderProgramPack pack)
+{
+	if (IsValid(programName))
+	{
+		CD_ENGINE_WARN("Program pack {0} already exists in ShaderLibrary!", cd::MoveTemp(programName));
+		return;
+	}
+
+	m_shaderPrograms[cd::MoveTemp(programName)] = cd::MoveTemp(pack);
+}
+
+void ShaderVariantCollectionsComponent::ActivateShaderFeature(std::string programName, ShaderFeature feature)
+{
+	assert(IsValid(programName) && "Program does not exist in ShaderLibrary!");
+
+	m_shaderPrograms[cd::MoveTemp(programName)].ActivateShaderFeature(cd::MoveTemp(feature));
+}
 
+void ShaderVariantCollectionsComponent::DeactiveShaderFeature(std::string programName, ShaderFeature feature)
+{
+	assert(IsValid(programName) && "Shader information does not exist!");
+
+	m_shaderPrograms[cd::MoveTemp(programName)].DeactivateShaderFeature(cd::MoveTemp(feature));
+}
+
+void ShaderVariantCollectionsComponent::SetShaderPrograms(std::map<std::string, ShaderProgramPack> program)
+{
+	m_shaderPrograms = cd::MoveTemp(program);
+}
+
+bool ShaderVariantCollectionsComponent::IsValid(std::string path) const
+{
+	return (m_shaderPrograms.find(cd::MoveTemp(path)) != m_shaderPrograms.end());
+}
 
 }

Engine/Source/Runtime/ECWorld/ShaderVariantCollectionsComponent.h

@@ -2,12 +2,20 @@
 
 #include "Base/Template.h"
 #include "Core/StringCrc.h"
+#include "Rendering/ShaderProgramPack.h"
+
+#include <map>
+#include <memory>
+#include <string>
 
 namespace engine
 {
 
 class ShaderVariantCollectionsComponent final
 {
+public:
+		using ShaderBlob = std::vector<std::byte>;
+
 public:
 	static constexpr StringCrc GetClassName()
 	{
@@ -22,8 +30,27 @@ class ShaderVariantCollectionsComponent final
 	ShaderVariantCollectionsComponent& operator=(ShaderVariantCollectionsComponent&&) = default;
 	~ShaderVariantCollectionsComponent() = default;
 
+	void RegisterPragram(std::string programName, ShaderProgramPack pack);
+
+	void ActivateShaderFeature(std::string programName, ShaderFeature feature);
+	void DeactiveShaderFeature(std::string programName, ShaderFeature feature);
+
+	void SetShaderPrograms(std::map<std::string, ShaderProgramPack> program);
+	std::map<std::string, ShaderProgramPack>& GetShaderInformations() { return m_shaderPrograms; }
+	const std::map<std::string, ShaderProgramPack>& GetShaderInformations() const { return m_shaderPrograms; }
+
 private:
+	inline bool IsValid(std::string path) const;
+
+	// Key : Shader source file path, Value : Shader feature set.
+	// Non-Uber shader has no features, in this case the value will be an empty std::set.
+	// std::map<std::string, ShaderFeatureSet> m_shaderInformations;
+
+	// Key : Program Name, Value : VS Path + FS Path + variant.
+	std::map<std::string, ShaderProgramPack> m_shaderPrograms;
 
+	// Key : Compiled Binary Shader File Name, Value : File Data.
+	// std::map<std::string, std::unique_ptr<ShaderBlob>> m_shaderData;
 };
 
 }

Engine/Source/Runtime/ECWorld/SkyComponent.cpp

@@ -3,19 +3,19 @@
 namespace engine
 {
 
-void SkyComponent::SetSkyType(SkyType crtType)
+void SkyComponent::SetSkyType(SkyType type)
 {
-	if (m_type == crtType)
+	if (m_type == type)
 	{
 		return;
 	}
 
-	m_type = crtType;
+	m_type = type;
 	static std::string preRadPath = m_radianceTexturePath;
 	if (SkyType::None == m_type)
 	{
 		preRadPath = cd::MoveTemp(m_radianceTexturePath);
-		m_radianceTexturePath = SkyComponent::PureGrayTexturePath;
+		m_radianceTexturePath = m_pureGrayTexturePath;
 	}
 	else if(preRadPath != m_radianceTexturePath)
 	{
@@ -38,4 +38,9 @@ void SkyComponent::SetRadianceTexturePath(std::string path)
 	m_radianceTexturePath = cd::MoveTemp(path);
 }
 
+void SkyComponent::SetPureGrayTexturePath(std::string path)
+{
+	m_pureGrayTexturePath = cd::MoveTemp(path);
+}
+
 }

Engine/Source/Runtime/ECWorld/SkyComponent.h

@@ -23,7 +23,7 @@ class SkyComponent final
 public:
 	static constexpr const char* DefaultIrradainceTexturePath = "Textures/skybox/defaultSkybox_irr.dds";
 	static constexpr const char* DefaultRadianceTexturePath = "Textures/skybox/defaultSkybox_rad.dds";
-	static constexpr const char* PureGrayTexturePath = "Textures/skybox/PureGray.dds";
+	static constexpr const char* DefaultPureGrayTexturePath = "Textures/skybox/PureGray.dds";
 
 public:
 	static constexpr StringCrc GetClassName()
@@ -39,7 +39,7 @@ class SkyComponent final
 	SkyComponent& operator=(SkyComponent&&) = default;
 	~SkyComponent() = default;
 
-	void SetSkyType(SkyType crtType);
+	void SetSkyType(SkyType type);
 	SkyType& GetSkyType() { return m_type; }
 	const SkyType& GetSkyType() const { return m_type; }
 
@@ -79,6 +79,10 @@ class SkyComponent final
 	std::string& GetRadianceTexturePath() { return m_radianceTexturePath; }
 	const std::string& GetRadianceTexturePath() const { return m_radianceTexturePath; }
 
+	void SetPureGrayTexturePath(std::string path);
+	std::string& GetPureGrayTexturePath() { return m_pureGrayTexturePath; }
+	const std::string& GetPureGrayTexturePath() const { return m_pureGrayTexturePath; }
+
 private:
 	SkyType m_type = SkyType::SkyBox;
 	bool m_isAtmophericScatteringEnable = false;
@@ -94,6 +98,7 @@ class SkyComponent final
 
 	std::string m_irradianceTexturePath = DefaultIrradainceTexturePath;
 	std::string m_radianceTexturePath = DefaultRadianceTexturePath;
+	std::string m_pureGrayTexturePath = DefaultPureGrayTexturePath;
 };
 
 }

Engine/Source/Runtime/ECWorld/TerrainComponent.h

@@ -61,7 +61,7 @@ class TerrainComponent final
 	uint16_t m_meshWidth = 129U;//uint32_t is too big for width
 	uint16_t m_meshDepth = 129U;
 
-	//height map input
+	//m_height map input
 	uint16_t m_texWidth = 129U;//uint32_t is too big for width
 	uint16_t m_texDepth = 129U;//
 	float m_roughness = 1.55f;