Move scene viewport shaders into editor resources

tests/editor/test_scene_viewport_shader_paths.cpp

@@ -0,0 +1,92 @@
+#include <gtest/gtest.h>
+
+#include "Viewport/SceneViewportShaderPaths.h"
+
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Resources/Shader/ShaderLoader.h>
+
+#include <filesystem>
+#include <string>
+
+namespace {
+
+using XCEngine::Editor::GetSceneViewportInfiniteGridShaderPath;
+using XCEngine::Editor::GetSceneViewportObjectIdOutlineShaderPath;
+using XCEngine::Resources::LoadResult;
+using XCEngine::Resources::ResourceHandle;
+using XCEngine::Resources::ResourceManager;
+using XCEngine::Resources::Shader;
+using XCEngine::Resources::ShaderBackend;
+using XCEngine::Resources::ShaderLoader;
+using XCEngine::Resources::ShaderPass;
+using XCEngine::Resources::ShaderStageVariant;
+using XCEngine::Resources::ShaderType;
+
+TEST(SceneViewportShaderPathsTest, ResolvePathsUnderEditorResources) {
+    const std::filesystem::path gridPath(GetSceneViewportInfiniteGridShaderPath().CStr());
+    const std::filesystem::path outlinePath(GetSceneViewportObjectIdOutlineShaderPath().CStr());
+
+    EXPECT_TRUE(gridPath.is_absolute());
+    EXPECT_TRUE(outlinePath.is_absolute());
+    EXPECT_TRUE(std::filesystem::exists(gridPath));
+    EXPECT_TRUE(std::filesystem::exists(outlinePath));
+    EXPECT_NE(gridPath.generic_string().find("editor/resources/shaders/scene-viewport"), std::string::npos);
+    EXPECT_NE(outlinePath.generic_string().find("editor/resources/shaders/scene-viewport"), std::string::npos);
+}
+
+TEST(SceneViewportShaderPathsTest, ShaderLoaderLoadsSceneViewportInfiniteGridShader) {
+    ShaderLoader loader;
+    const auto shaderPath = GetSceneViewportInfiniteGridShaderPath();
+    EXPECT_TRUE(loader.CanLoad(shaderPath));
+
+    LoadResult result = loader.Load(shaderPath);
+    ASSERT_TRUE(result);
+    ASSERT_NE(result.resource, nullptr);
+
+    auto* shader = static_cast<Shader*>(result.resource);
+    ASSERT_NE(shader, nullptr);
+    ASSERT_TRUE(shader->IsValid());
+
+    const ShaderPass* pass = shader->FindPass("InfiniteGrid");
+    ASSERT_NE(pass, nullptr);
+    ASSERT_EQ(pass->variants.Size(), 2u);
+    ASSERT_EQ(pass->tags.Size(), 1u);
+    EXPECT_EQ(pass->tags[0].name, "LightMode");
+    EXPECT_EQ(pass->tags[0].value, "InfiniteGrid");
+
+    const ShaderStageVariant* fragment = shader->FindVariant(
+        "InfiniteGrid",
+        ShaderType::Fragment,
+        ShaderBackend::D3D12);
+    ASSERT_NE(fragment, nullptr);
+    EXPECT_NE(
+        std::string(fragment->sourceCode.CStr()).find("XC_EDITOR_SCENE_VIEW_INFINITE_GRID_D3D12_PS"),
+        std::string::npos);
+
+    delete shader;
+}
+
+TEST(SceneViewportShaderPathsTest, ResourceManagerLoadsSceneViewportOutlineShaderByResolvedPath) {
+    ResourceManager& manager = ResourceManager::Get();
+    manager.Shutdown();
+
+    const ResourceHandle<Shader> shaderHandle = manager.Load<Shader>(GetSceneViewportObjectIdOutlineShaderPath());
+    ASSERT_TRUE(shaderHandle.IsValid());
+
+    const ShaderPass* pass = shaderHandle->FindPass("ObjectIdOutline");
+    ASSERT_NE(pass, nullptr);
+    ASSERT_EQ(pass->variants.Size(), 2u);
+
+    const ShaderStageVariant* fragment = shaderHandle->FindVariant(
+        "ObjectIdOutline",
+        ShaderType::Fragment,
+        ShaderBackend::D3D12);
+    ASSERT_NE(fragment, nullptr);
+    EXPECT_NE(
+        std::string(fragment->sourceCode.CStr()).find("XC_EDITOR_SCENE_VIEW_OBJECT_ID_OUTLINE_D3D12_PS"),
+        std::string::npos);
+
+    manager.Shutdown();
+}
+
+} // namespace