Move scene viewport shaders into editor resources

engine/src/Rendering/Passes/BuiltinInfiniteGridPass.cpp

@@ -6,12 +6,12 @@
 #include <XCEngine/Debug/Logger.h>
 #include <XCEngine/RHI/RHICommandList.h>
 #include <XCEngine/RHI/RHIDevice.h>
-#include <XCEngine/Resources/BuiltinResources.h>
 
 #include "Rendering/Detail/ShaderVariantUtils.h"
 
 #include <algorithm>
 #include <cmath>
+#include <utility>
 
 namespace XCEngine {
 namespace Rendering {
@@ -140,6 +140,23 @@ InfiniteGridParameters BuildInfiniteGridParameters(const InfiniteGridPassData& d
     return parameters;
 }
 
+BuiltinInfiniteGridPass::BuiltinInfiniteGridPass(Containers::String shaderPath)
+    : m_shaderPath(std::move(shaderPath)) {
+}
+
+void BuiltinInfiniteGridPass::SetShaderPath(const Containers::String& shaderPath) {
+    if (m_shaderPath == shaderPath) {
+        return;
+    }
+
+    DestroyResources();
+    m_shaderPath = shaderPath;
+}
+
+const Containers::String& BuiltinInfiniteGridPass::GetShaderPath() const {
+    return m_shaderPath;
+}
+
 void BuiltinInfiniteGridPass::Shutdown() {
     DestroyResources();
 }
@@ -243,14 +260,21 @@ bool BuiltinInfiniteGridPass::CreateResources(const RenderContext& renderContext
         return false;
     }
 
+    if (m_shaderPath.Empty()) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            "BuiltinInfiniteGridPass requires an injected shader path before resource creation");
+        return false;
+    }
+
     m_device = renderContext.device;
     m_backendType = renderContext.backendType;
     m_builtinInfiniteGridShader = Resources::ResourceManager::Get().Load<Resources::Shader>(
-        Resources::GetBuiltinInfiniteGridShaderPath());
+        m_shaderPath);
     if (!m_builtinInfiniteGridShader.IsValid()) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinInfiniteGridPass failed to load builtin infinite-grid shader resource");
+            "BuiltinInfiniteGridPass failed to load configured infinite-grid shader resource");
         DestroyResources();
         return false;
     }

engine/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp

@@ -6,7 +6,6 @@
 #include "Rendering/Detail/ShaderVariantUtils.h"
 #include "RHI/RHICommandList.h"
 #include "RHI/RHIDevice.h"
-#include "Resources/BuiltinResources.h"
 
 #include <algorithm>
 #include <utility>
@@ -86,10 +85,24 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc(
 
 } // namespace
 
-BuiltinObjectIdOutlinePass::BuiltinObjectIdOutlinePass() {
+BuiltinObjectIdOutlinePass::BuiltinObjectIdOutlinePass(Containers::String shaderPath)
+    : m_shaderPath(std::move(shaderPath)) {
     ResetState();
 }
 
+void BuiltinObjectIdOutlinePass::SetShaderPath(const Containers::String& shaderPath) {
+    if (m_shaderPath == shaderPath) {
+        return;
+    }
+
+    DestroyResources();
+    m_shaderPath = shaderPath;
+}
+
+const Containers::String& BuiltinObjectIdOutlinePass::GetShaderPath() const {
+    return m_shaderPath;
+}
+
 void BuiltinObjectIdOutlinePass::Shutdown() {
     DestroyResources();
 }
@@ -197,12 +210,19 @@ bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderCont
         return false;
     }
 
+    if (m_shaderPath.Empty()) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            "BuiltinObjectIdOutlinePass requires an injected shader path before resource creation");
+        return false;
+    }
+
     Resources::ResourceHandle<Resources::Shader> shader = Resources::ResourceManager::Get().Load<Resources::Shader>(
-        Resources::GetBuiltinObjectIdOutlineShaderPath());
+        m_shaderPath);
     if (!shader.IsValid()) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinObjectIdOutlinePass failed to load builtin object-id-outline shader resource");
+            "BuiltinObjectIdOutlinePass failed to load configured object-id-outline shader resource");
         ResetState();
         return false;
     }

engine/src/Resources/BuiltinResources.cpp

@@ -29,8 +29,6 @@ constexpr const char* kBuiltinTexturePrefix = "builtin://textures/";
 constexpr const char* kBuiltinDefaultPrimitiveMaterialPath = "builtin://materials/default-primitive";
 constexpr const char* kBuiltinForwardLitShaderPath = "builtin://shaders/forward-lit";
 constexpr const char* kBuiltinObjectIdShaderPath = "builtin://shaders/object-id";
-constexpr const char* kBuiltinObjectIdOutlineShaderPath = "builtin://shaders/object-id-outline";
-constexpr const char* kBuiltinInfiniteGridShaderPath = "builtin://shaders/infinite-grid";
 constexpr const char* kBuiltinDefaultPrimitiveTexturePath = "builtin://textures/default-primitive-albedo";
 constexpr float kPi = 3.14159265358979323846f;
 
@@ -45,10 +43,6 @@ constexpr const char* kBuiltinForwardLitShaderManifestRelativePath =
     "engine/assets/builtin/shaders/forward-lit/forward-lit.shader";
 constexpr const char* kBuiltinObjectIdShaderManifestRelativePath =
     "engine/assets/builtin/shaders/object-id/object-id.shader";
-constexpr const char* kBuiltinObjectIdOutlineShaderManifestRelativePath =
-    "engine/assets/builtin/shaders/object-id-outline/object-id-outline.shader";
-constexpr const char* kBuiltinInfiniteGridShaderManifestRelativePath =
-    "engine/assets/builtin/shaders/infinite-grid/infinite-grid.shader";
 
 Containers::String NormalizeBuiltinAssetPath(const std::filesystem::path& path) {
     return Containers::String(path.lexically_normal().generic_string().c_str());
@@ -118,12 +112,6 @@ const char* GetBuiltinShaderManifestRelativePath(const Containers::String& built
     if (builtinShaderPath == Containers::String(kBuiltinObjectIdShaderPath)) {
         return kBuiltinObjectIdShaderManifestRelativePath;
     }
-    if (builtinShaderPath == Containers::String(kBuiltinObjectIdOutlineShaderPath)) {
-        return kBuiltinObjectIdOutlineShaderManifestRelativePath;
-    }
-    if (builtinShaderPath == Containers::String(kBuiltinInfiniteGridShaderPath)) {
-        return kBuiltinInfiniteGridShaderManifestRelativePath;
-    }
 
     return nullptr;
 }
@@ -652,14 +640,6 @@ Shader* BuildBuiltinObjectIdShader(const Containers::String& path) {
     return TryLoadBuiltinShaderFromManifest(path);
 }
 
-Shader* BuildBuiltinInfiniteGridShader(const Containers::String& path) {
-    return TryLoadBuiltinShaderFromManifest(path);
-}
-
-Shader* BuildBuiltinObjectIdOutlineShader(const Containers::String& path) {
-    return TryLoadBuiltinShaderFromManifest(path);
-}
-
 Material* BuildDefaultPrimitiveMaterial(const Containers::String& path) {
     auto* material = new Material();
     IResource::ConstructParams params;
@@ -766,14 +746,6 @@ Containers::String GetBuiltinObjectIdShaderPath() {
     return Containers::String(kBuiltinObjectIdShaderPath);
 }
 
-Containers::String GetBuiltinObjectIdOutlineShaderPath() {
-    return Containers::String(kBuiltinObjectIdOutlineShaderPath);
-}
-
-Containers::String GetBuiltinInfiniteGridShaderPath() {
-    return Containers::String(kBuiltinInfiniteGridShaderPath);
-}
-
 Containers::String GetBuiltinDefaultPrimitiveTexturePath() {
     return Containers::String(kBuiltinDefaultPrimitiveTexturePath);
 }
@@ -866,10 +838,6 @@ LoadResult CreateBuiltinShaderResource(const Containers::String& path) {
         shader = BuildBuiltinForwardLitShader(path);
     } else if (path == GetBuiltinObjectIdShaderPath()) {
         shader = BuildBuiltinObjectIdShader(path);
-    } else if (path == GetBuiltinObjectIdOutlineShaderPath()) {
-        shader = BuildBuiltinObjectIdOutlineShader(path);
-    } else if (path == GetBuiltinInfiniteGridShaderPath()) {
-        shader = BuildBuiltinInfiniteGridShader(path);
     } else {
         return LoadResult(Containers::String("Unknown builtin shader: ") + path);
     }